home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / tos / updates / update28.zoo / libg++ / src / diffcc next >
Encoding:
Text File  |  1993-02-22  |  97.4 KB  |  4,033 lines

  1. *** 1.11    1992/12/28 07:42:38
  2. --- Changelo    1993/02/22 17:06:27
  3. ***************
  4. *** 291,293 ****
  5. --- 291,298 ----
  6.       i have done allthe non-io classes. still working on those.
  7.   
  8.   ---------------------------- Patchlevel 16 -----------------------------------
  9. + *.cc:: ++jrb
  10. +     sync up with rest of libg++-2.3. all classes done now.
  11. + ---------------------------- Patchlevel 17 -----------------------------------
  12. *** 1.11    1992/12/28 07:42:38
  13. --- PatchLev.h    1993/02/22 17:06:28
  14. ***************
  15. *** 1,5 ****
  16.   
  17. ! #define    PatchLevel "16"
  18.   
  19.   /*
  20.    *    the Patch Level above is to identify the version
  21. --- 1,5 ----
  22.   
  23. ! #define    PatchLevel "17"
  24.   
  25.   /*
  26.    *    the Patch Level above is to identify the version
  27. *** 1.2    1992/06/03 02:12:17
  28. --- editbuf.cc    1993/02/22 17:06:30
  29. ***************
  30. *** 102,108 ****
  31.       gap_right (pos);
  32.   }
  33.   
  34. ! void edit_buffer::gap_left (size_t pos)
  35.   {
  36.     register buf_char *to, *from;
  37.     register long i;
  38. --- 102,108 ----
  39.       gap_right (pos);
  40.   }
  41.   
  42. ! void edit_buffer::gap_left (_G_size_t pos)
  43.   {
  44.     register buf_char *to, *from;
  45.     register long i;
  46. ***************
  47. *** 153,159 ****
  48.   /*  QUIT;*/
  49.   }
  50.   
  51. ! void edit_buffer::gap_right (size_t pos)
  52.   {
  53.     register buf_char *to, *from;
  54.     register long i;
  55. --- 153,159 ----
  56.   /*  QUIT;*/
  57.   }
  58.   
  59. ! void edit_buffer::gap_right (_G_size_t pos)
  60.   {
  61.     register buf_char *to, *from;
  62.     register long i;
  63. ***************
  64. *** 209,215 ****
  65.   {
  66.     register buf_char *p1, *p2, *lim;
  67.     buf_char *old_data = data;
  68. !   int long s1 = size1();
  69.   
  70.     if (gap_size() >= k)
  71.       return;
  72. --- 209,215 ----
  73.   {
  74.     register buf_char *p1, *p2, *lim;
  75.     buf_char *old_data = data;
  76. !   long s1 = size1();
  77.   
  78.     if (gap_size() >= k)
  79.       return;
  80. ***************
  81. *** 428,434 ****
  82.   // Called by fseek(fp, pos, whence) if fp is bound to a edit_buffer.
  83.   
  84.   streampos edit_streambuf::seekoff(streamoff offset, _seek_dir dir,
  85. !                   int mode=ios::in|ios::out)
  86.   {
  87.       struct edit_buffer *buffer = str->buffer;
  88.       disconnect_gap_from_file(buffer);
  89. --- 428,434 ----
  90.   // Called by fseek(fp, pos, whence) if fp is bound to a edit_buffer.
  91.   
  92.   streampos edit_streambuf::seekoff(streamoff offset, _seek_dir dir,
  93. !                   int mode /* =ios::in|ios::out*/)
  94.   {
  95.       struct edit_buffer *buffer = str->buffer;
  96.       disconnect_gap_from_file(buffer);
  97. ***************
  98. *** 586,592 ****
  99.   edit_buffer::edit_buffer()
  100.   {
  101.       buf_size = /*200;*/ 15; /* for testing! */
  102. !     data = malloc(buf_size);
  103.       files = NULL;
  104.   #ifndef OLD_STDIO
  105.       _gap_start = data;
  106. --- 586,592 ----
  107.   edit_buffer::edit_buffer()
  108.   {
  109.       buf_size = /*200;*/ 15; /* for testing! */
  110. !     data = (buf_char*)malloc(buf_size);
  111.       files = NULL;
  112.   #ifndef OLD_STDIO
  113.       _gap_start = data;
  114. ***************
  115. *** 611,617 ****
  116.       chain = buf->start_mark.chain;
  117.       buf->start_mark.chain = this;
  118.       mark_pointer size1 = buf->size1() << 1;
  119. !     size_t gap_size = buf->gap_size() << 1;
  120.       delta <<= 1;
  121.   
  122.       // check if new and old marks are opposite sides of gap
  123. --- 611,617 ----
  124.       chain = buf->start_mark.chain;
  125.       buf->start_mark.chain = this;
  126.       mark_pointer size1 = buf->size1() << 1;
  127. !     _G_size_t gap_size = buf->gap_size() << 1;
  128.       delta <<= 1;
  129.   
  130.       // check if new and old marks are opposite sides of gap
  131. ***************
  132. *** 647,653 ****
  133.       *ptr = this->chain;
  134.   }
  135.   
  136. ! size_t edit_string::length() const
  137.   {
  138.       ptrdiff_t delta = end->ptr(buffer) - start->ptr(buffer);
  139.       if (end->ptr(buffer) <= buffer->gap_start() ||
  140. --- 647,653 ----
  141.       *ptr = this->chain;
  142.   }
  143.   
  144. ! _G_size_t edit_string::length() const
  145.   {
  146.       ptrdiff_t delta = end->ptr(buffer) - start->ptr(buffer);
  147.       if (end->ptr(buffer) <= buffer->gap_start() ||
  148. ***************
  149. *** 656,665 ****
  150.       return delta - buffer->gap_size();
  151.   }
  152.   
  153. ! buf_char * edit_string::copy_bytes(size_t *lenp) const
  154.   {
  155.       char *new_str;
  156. !     size_t len1, len2;
  157.       buf_char *start1, *start2;
  158.       start1 = start->ptr(buffer);
  159.       if (end->ptr(buffer) <= buffer->gap_start()
  160. --- 656,665 ----
  161.       return delta - buffer->gap_size();
  162.   }
  163.   
  164. ! buf_char * edit_string::copy_bytes(_G_size_t *lenp) const
  165.   {
  166.       char *new_str;
  167. !     _G_size_t len1, len2;
  168.       buf_char *start1, *start2;
  169.       start1 = start->ptr(buffer);
  170.       if (end->ptr(buffer) <= buffer->gap_start()
  171. ***************
  172. *** 691,697 ****
  173.   {
  174.       edit_streambuf dst_file(this, ios::out);
  175.       if (buffer == src->buffer /*&& ???*/) { /* overly conservative */
  176. !     size_t src_len;
  177.       buf_char *new_str;
  178.       new_str = src->copy_bytes(&src_len);
  179.       dst_file.sputn(new_str, src_len);
  180. --- 691,697 ----
  181.   {
  182.       edit_streambuf dst_file(this, ios::out);
  183.       if (buffer == src->buffer /*&& ???*/) { /* overly conservative */
  184. !     _G_size_t src_len;
  185.       buf_char *new_str;
  186.       new_str = src->copy_bytes(&src_len);
  187.       dst_file.sputn(new_str, src_len);
  188. *** 1.8    1992/12/11 19:39:04
  189. --- filebuf.cc    1993/02/22 17:06:31
  190. ***************
  191. *** 17,23 ****
  192.   
  193.   #include <ioprivat.h>
  194.   #include <sys/types.h>
  195. - #include <sys/file.h>
  196.   #include <sys/stat.h>
  197.   #include <fcntl.h>
  198.   #include <errno.h>
  199. --- 17,22 ----
  200. ***************
  201. *** 76,105 ****
  202.       _fb._fileno = -1;
  203.   }
  204.   
  205. - void streambuf::_un_link()
  206. - {
  207. -     if (_flags & _S_LINKED) {
  208. -     streambuf **f;
  209. -     for (f = &_list_all; *f != NULL; f = &(*f)->xchain()) {
  210. -         if (*f == this) {
  211. -         *f = xchain();
  212. -         break;
  213. -         }
  214. -     }
  215. -     _flags &= ~_S_LINKED;
  216. -     }
  217. - }
  218. - void streambuf::_link_in()
  219. - {
  220. -     if ((_flags & _S_LINKED) == 0) {
  221. -     _flags |= _S_LINKED;
  222. -     xchain() = _list_all;
  223. -     _list_all = this;
  224. -     }
  225. - }
  226.   filebuf::filebuf() : backupbuf(CLOSED_FILEBUF_FLAGS)
  227.   {
  228.       init();
  229. --- 75,80 ----
  230. ***************
  231. *** 111,117 ****
  232.       attach(fd);
  233.   }
  234.   
  235. ! filebuf::filebuf(int fd, char* p, size_t len) : backupbuf(CLOSED_FILEBUF_FLAGS)
  236.   {
  237.       init();
  238.       attach(fd);
  239. --- 86,92 ----
  240.       attach(fd);
  241.   }
  242.   
  243. ! filebuf::filebuf(int fd, char* p, _G_size_t len) : backupbuf(CLOSED_FILEBUF_FLAGS)
  244.   {
  245.       init();
  246.       attach(fd);
  247. ***************
  248. *** 127,136 ****
  249.   }
  250.   
  251.   #ifdef atarist
  252. ! extern "C" extern int __default_mode__;
  253.   #endif
  254.   
  255. ! filebuf* filebuf::open(const char *filename, int mode, int prot)
  256.   {
  257.       if (is_open())
  258.       return NULL;
  259. --- 102,111 ----
  260.   }
  261.   
  262.   #ifdef atarist
  263. ! extern "C" int __default_mode__;
  264.   #endif
  265.   
  266. ! filebuf* filebuf::open(const char *filename, ios::openmode mode, int prot)
  267.   {
  268.       if (is_open())
  269.       return NULL;
  270. ***************
  271. *** 139,149 ****
  272.   #ifdef atarist
  273.       int rw_mode = (__default_mode__) ? _S_IS_BINARY : 0;
  274.   #endif
  275.       if ((mode & (ios::in|ios::out)) == (ios::in|ios::out)) {
  276.       posix_mode = O_RDWR;
  277.       read_write = 0;
  278.       }
  279. !     else if (mode & (ios::out|ios::app))
  280.       posix_mode = O_WRONLY, read_write = _S_NO_READS;
  281.       else if (mode & (int)ios::in)
  282.       posix_mode = O_RDONLY, read_write = _S_NO_WRITES;
  283. --- 114,126 ----
  284.   #ifdef atarist
  285.       int rw_mode = (__default_mode__) ? _S_IS_BINARY : 0;
  286.   #endif
  287. +     if (mode & ios::app)
  288. +     mode |= ios::out;
  289.       if ((mode & (ios::in|ios::out)) == (ios::in|ios::out)) {
  290.       posix_mode = O_RDWR;
  291.       read_write = 0;
  292.       }
  293. !     else if (mode & ios::out)
  294.       posix_mode = O_WRONLY, read_write = _S_NO_READS;
  295.       else if (mode & (int)ios::in)
  296.       posix_mode = O_RDONLY, read_write = _S_NO_WRITES;
  297. ***************
  298. *** 152,158 ****
  299.       if ((mode & (int)ios::trunc) || mode == (int)ios::out)
  300.       posix_mode |= O_TRUNC;
  301.       if (mode & ios::app)
  302. !     posix_mode |= O_APPEND;
  303.       if (!(mode & (int)ios::nocreate) && mode != ios::in)
  304.       posix_mode |= O_CREAT;
  305.       if (mode & (int)ios::noreplace)
  306. --- 129,135 ----
  307.       if ((mode & (int)ios::trunc) || mode == (int)ios::out)
  308.       posix_mode |= O_TRUNC;
  309.       if (mode & ios::app)
  310. !     posix_mode |= O_APPEND, read_write |= _S_IS_APPENDING;
  311.       if (!(mode & (int)ios::nocreate) && mode != ios::in)
  312.       posix_mode |= O_CREAT;
  313.       if (mode & (int)ios::noreplace)
  314. ***************
  315. *** 167,177 ****
  316.       else if(mode & (int)ios::text)
  317.       rw_mode &= ~_S_IS_BINARY;
  318.       read_write |= rw_mode;
  319. !     xsetflags(read_write, (_S_NO_READS+_S_NO_WRITES)|rw_mode);
  320.   #else
  321. !     xsetflags(read_write, _S_NO_READS+_S_NO_WRITES);
  322.   #endif
  323. !     if (mode & ios::ate) {
  324.       if (seekoff(0, ios::end) == EOF)
  325.           return NULL;
  326.       }
  327. --- 144,154 ----
  328.       else if(mode & (int)ios::text)
  329.       rw_mode &= ~_S_IS_BINARY;
  330.       read_write |= rw_mode;
  331. !     xsetflags(read_write, (_S_NO_READS+_S_NO_WRITES+_S_IS_APPENDING)|rw_mode);
  332.   #else
  333. !     xsetflags(read_write, _S_NO_READS+_S_NO_WRITES+_S_IS_APPENDING);
  334.   #endif
  335. !     if (mode & (ios::ate|ios::app)) {
  336.       if (seekoff(0, ios::end) == EOF)
  337.           return NULL;
  338.       }
  339. ***************
  340. *** 202,208 ****
  341.         case 'a':
  342.       omode = O_WRONLY;
  343.       oflags = O_CREAT|O_APPEND;
  344. !     read_write = _S_NO_READS;
  345.       break;
  346.   #ifdef atarist
  347.         case 'b':
  348. --- 179,185 ----
  349.         case 'a':
  350.       omode = O_WRONLY;
  351.       oflags = O_CREAT|O_APPEND;
  352. !     read_write = _S_NO_READS|_S_IS_APPENDING;
  353.       break;
  354.   #ifdef atarist
  355.         case 'b':
  356. ***************
  357. *** 226,235 ****
  358.       _fb._fileno = fdesc;
  359.   #ifdef atarist
  360.       read_write |= rw_mode;
  361. !     xsetflags(read_write, (_S_NO_READS+_S_NO_WRITES)|rw_mode);
  362.   #else
  363. !     xsetflags(read_write, _S_NO_READS+_S_NO_WRITES);
  364.   #endif
  365.       _link_in();
  366.       return this;
  367.   }
  368. --- 203,215 ----
  369.       _fb._fileno = fdesc;
  370.   #ifdef atarist
  371.       read_write |= rw_mode;
  372. !     xsetflags(read_write, (_S_NO_READS+_S_NO_WRITES+_S_IS_APPENDING)|rw_mode);
  373.   #else
  374. !     xsetflags(read_write, _S_NO_READS+_S_NO_WRITES+_S_IS_APPENDING);
  375.   #endif
  376. +     if (read_write & _S_IS_APPENDING)
  377. +     if (seekoff(0, ios::end) == EOF)
  378. +         return NULL;
  379.       _link_in();
  380.       return this;
  381.   }
  382. ***************
  383. *** 240,255 ****
  384.       return NULL;
  385.       _fb._fileno = fd;
  386.   #ifdef atarist
  387. !     xsetflags(_S_DELETE_DONT_CLOSE |((__default_mode__)? _S_IS_BINARY : 0),
  388. !           (_S_DELETE_DONT_CLOSE+_S_NO_READS+_S_NO_WRITES) |
  389. !            ((__default_mode__)? _S_IS_BINARY : 0));
  390.   #else
  391. !     xsetflags(_S_DELETE_DONT_CLOSE,
  392. !           _S_DELETE_DONT_CLOSE+_S_NO_READS+_S_NO_WRITES);
  393.   #endif
  394.       return this;
  395.   }
  396.   
  397.   int filebuf::overflow(int c)
  398.   {
  399.       if (xflags() & _S_NO_WRITES) // SET ERROR
  400. --- 220,242 ----
  401.       return NULL;
  402.       _fb._fileno = fd;
  403.   #ifdef atarist
  404. !     xsetflags((__default_mode__)? _S_IS_BINARY : 0,
  405. !       (_S_NO_READS+_S_NO_WRITES) | ((__default_mode__) ? _S_IS_BINARY : 0));
  406.   #else
  407. !     xsetflags(0, _S_NO_READS+_S_NO_WRITES);
  408.   #endif
  409.       return this;
  410.   }
  411.   
  412. + streambuf* filebuf::setbuf(char* p, _G_size_t len)
  413. + {
  414. +     if (streambuf::setbuf(p, len) == NULL)
  415. +     return NULL;
  416. +     setp(_base, _base);
  417. +     setg(_base, _base, _base);
  418. +     return this;
  419. + }
  420.   int filebuf::overflow(int c)
  421.   {
  422.       if (xflags() & _S_NO_WRITES) // SET ERROR
  423. ***************
  424. *** 289,295 ****
  425.       return (EOF);
  426.   #endif
  427.   
  428. !    if (xflags() & _S_NO_READS)
  429.       return EOF;
  430.       if (gptr() < egptr())
  431.       return *(unsigned char*)gptr();
  432. --- 276,282 ----
  433.       return (EOF);
  434.   #endif
  435.   
  436. !     if (xflags() & _S_NO_READS)
  437.       return EOF;
  438.       if (gptr() < egptr())
  439.       return *(unsigned char*)gptr();
  440. ***************
  441. *** 305,312 ****
  442.       if (do_flush()) return EOF;
  443.   #endif
  444.   
  445. -     switch_to_get_mode();
  446.       _G_ssize_t count = sys_read(base(), ebuf() - base());
  447.       if (count <= 0) {
  448.       if (count == 0)
  449. --- 292,297 ----
  450. ***************
  451. *** 323,333 ****
  452.       return *(unsigned char*)gptr();
  453.   }
  454.   
  455. ! int filebuf::do_write(const char *data, int to_do)
  456.   {
  457.       if (to_do == 0)
  458.       return 0;
  459. !     if (egptr() != pbase()) {
  460.       long new_pos = sys_seek(pbase()-egptr(), ios::cur);
  461.       if (new_pos == -1)
  462.           return EOF;
  463. --- 308,326 ----
  464.       return *(unsigned char*)gptr();
  465.   }
  466.   
  467. ! int filebuf::do_write(const char *data, _G_size_t to_do)
  468.   {
  469.       if (to_do == 0)
  470.       return 0;
  471. !     if (xflags() & _S_IS_APPENDING) {
  472. !     // On a system without a proper O_APPEND implementation,
  473. !     // you would need to sys_seek(0, ios::end) here, but is
  474. !     // is not needed nor desirable for Unix- or Posix-like systems.
  475. !     // Instead, just indicate that offset (before and after) is
  476. !     // unpredictable.
  477. !     _fb._offset = -1;
  478. !     }
  479. !     else if (egptr() != pbase()) {
  480.       long new_pos = sys_seek(pbase()-egptr(), ios::cur);
  481.       if (new_pos == -1)
  482.           return EOF;
  483. ***************
  484. *** 372,377 ****
  485. --- 365,373 ----
  486.       streampos result, new_offset, delta;
  487.       _G_ssize_t count;
  488.   
  489. +     if (mode == 0) // Don't move any pointers.
  490. +     dir = ios::cur, offset = 0;
  491.       // Flush unwritten characters.
  492.       // (This may do an unneeded write if we seek within the buffer.
  493.       // But to be able to switch to reading, we would need to set
  494. ***************
  495. *** 417,423 ****
  496.       // If destination is within current buffer, optimize:
  497.       if (_fb._offset >= 0 && _eback != NULL) {
  498.       // Offset relative to start of main get area.
  499. !     fpos_t rel_offset = offset - _fb._offset
  500.           + (eGptr()-Gbase());
  501.       if (rel_offset >= 0) {
  502.           if (in_backup())
  503. --- 413,419 ----
  504.       // If destination is within current buffer, optimize:
  505.       if (_fb._offset >= 0 && _eback != NULL) {
  506.       // Offset relative to start of main get area.
  507. !     _G_fpos_t rel_offset = offset - _fb._offset
  508.           + (eGptr()-Gbase());
  509.       if (rel_offset >= 0) {
  510.           if (in_backup())
  511. ***************
  512. *** 429,435 ****
  513.           }
  514.           // If we have streammarkers, seek forward by reading ahead.
  515.           if (have_markers()) {
  516. !         int to_skip = rel_offset - (_gptr - _eback);
  517.           if (ignore(to_skip) != to_skip)
  518.               goto dumb;
  519.           return offset;
  520. --- 425,431 ----
  521.           }
  522.           // If we have streammarkers, seek forward by reading ahead.
  523.           if (have_markers()) {
  524. !         long to_skip = rel_offset - (_gptr - _eback);
  525.           if (ignore(to_skip) != to_skip)
  526.               goto dumb;
  527.           return offset;
  528. ***************
  529. *** 512,541 ****
  530.   _G_ssize_t filebuf::sys_read(char* buf, size_t size)
  531.   {
  532.       for (;;) {
  533.       _G_ssize_t count = ::read(_fb._fileno, buf, size);
  534.       if (count != -1 || errno != EINTR)
  535.           return count;
  536.       }
  537.   }
  538.   
  539. ! fpos_t filebuf::sys_seek(fpos_t offset, _seek_dir dir)
  540.   {
  541.       return ::lseek(fd(), offset, (int)dir);
  542.   }
  543.   
  544. ! _G_ssize_t filebuf::sys_write(const void *buf, long n)
  545.   {
  546.       long to_do = n;
  547.       while (to_do > 0) {
  548.       _G_ssize_t count = ::write(fd(), buf, to_do);
  549.       if (count == EOF) {
  550.           if (errno == EINTR)
  551.           continue;
  552. !         else
  553.           break;
  554.       }
  555.       to_do -= count;
  556. !     buf += count;
  557.       }
  558.       n -= to_do;
  559.       if (_fb._offset >= 0)
  560. --- 508,547 ----
  561.   _G_ssize_t filebuf::sys_read(char* buf, size_t size)
  562.   {
  563.       for (;;) {
  564. + #ifdef atarist
  565. +     _G_ssize_t count = ::_read(_fb._fileno, buf, size);
  566. + #else
  567.       _G_ssize_t count = ::read(_fb._fileno, buf, size);
  568. + #endif
  569.       if (count != -1 || errno != EINTR)
  570.           return count;
  571.       }
  572.   }
  573.   
  574. ! _G_fpos_t filebuf::sys_seek(_G_fpos_t offset, _seek_dir dir)
  575.   {
  576.       return ::lseek(fd(), offset, (int)dir);
  577.   }
  578.   
  579. ! _G_ssize_t filebuf::sys_write(const void *buf, _G_size_t n)
  580.   {
  581.       long to_do = n;
  582.       while (to_do > 0) {
  583. + #ifdef atarist
  584. +     _G_ssize_t count = ::_write(fd(), buf, to_do);
  585. + #else
  586.       _G_ssize_t count = ::write(fd(), buf, to_do);
  587. + #endif
  588.       if (count == EOF) {
  589.           if (errno == EINTR)
  590.           continue;
  591. !         else {
  592. !         _flags |= _S_ERR_SEEN;
  593.           break;
  594. +         }
  595.       }
  596.       to_do -= count;
  597. !     buf = (void*)((char*)buf + count);
  598.       }
  599.       n -= to_do;
  600.       if (_fb._offset >= 0)
  601. ***************
  602. *** 553,569 ****
  603.       return ::close(fd());
  604.   }
  605.   
  606. ! size_t filebuf::sputn(const char *s, size_t n)
  607.   {
  608. !     if (n <= 0)
  609.       return 0;
  610.       // This is an optimized implementation.
  611.       // If the amount to be written straddles a block boundary
  612.       // (or the filebuf is unbuffered), use sys_write directly.
  613.   
  614. !     // First fill the buffer.
  615. !     int to_do = n;
  616. !     int count = _epptr - _pptr; // Space available.
  617.       if (count > 0) {
  618.       if (count > to_do)
  619.           count = to_do;
  620. --- 559,589 ----
  621.       return ::close(fd());
  622.   }
  623.   
  624. ! _G_size_t filebuf::xsputn(const char *s, _G_size_t n)
  625.   {
  626. !     if (n == 0)
  627.       return 0;
  628.       // This is an optimized implementation.
  629.       // If the amount to be written straddles a block boundary
  630.       // (or the filebuf is unbuffered), use sys_write directly.
  631.   
  632. !     _G_size_t to_do = n;
  633. !     int must_flush = 0;
  634. !     // First figure out how much space is available in the buffer.
  635. !     _G_size_t count = _epptr - _pptr; // Space available.
  636. !     if (linebuffered() && (_flags & _S_CURRENTLY_PUTTING)) {
  637. !     count =_ebuf - _pptr;
  638. !     if (count >= n) {
  639. !         for (register const char *p = s + n; p > s; ) {
  640. !         if (*--p == '\n') {
  641. !             count = p - s + 1;
  642. !             must_flush = 1;
  643. !             break;
  644. !         }
  645. !         }
  646. !     }
  647. !     }
  648. !     // Then fill the buffer.
  649.       if (count > 0) {
  650.       if (count > to_do)
  651.           count = to_do;
  652. ***************
  653. *** 573,584 ****
  654.       }
  655.       else {
  656.           register char *p = pptr();;
  657. !         for (register int i = count; --i >= 0; ) *p++ = *s++;
  658.       }
  659.       pbump(count);
  660.       to_do -= count;
  661.       }
  662. !     if (to_do > 0) {
  663.       // Next flush the (full) buffer.
  664.       if (__overflow(this, EOF) == EOF)
  665.           return n - to_do;
  666. --- 593,604 ----
  667.       }
  668.       else {
  669.           register char *p = pptr();;
  670. !         for (register _G_size_t i = count+1; --i > 0; ) *p++ = *s++;
  671.       }
  672.       pbump(count);
  673.       to_do -= count;
  674.       }
  675. !     if (to_do + must_flush > 0) {
  676.       // Next flush the (full) buffer.
  677.       if (__overflow(this, EOF) == EOF)
  678.           return n - to_do;
  679. ***************
  680. *** 585,592 ****
  681.   
  682.       // Try to maintain alignment: write a whole number of blocks.
  683.       // dont_write is what gets left over.
  684. !     int block_size = _ebuf - _base;
  685. !     int dont_write = block_size >= 128 ? to_do % block_size : 0;
  686.   
  687.       _G_ssize_t count = to_do - dont_write;
  688.       if (do_write(s, count) == EOF)
  689. --- 605,612 ----
  690.   
  691.       // Try to maintain alignment: write a whole number of blocks.
  692.       // dont_write is what gets left over.
  693. !     _G_size_t block_size = _ebuf - _base;
  694. !     _G_size_t dont_write = block_size >= 128 ? to_do % block_size : 0;
  695.   
  696.       _G_ssize_t count = to_do - dont_write;
  697.       if (do_write(s, count) == EOF)
  698. ***************
  699. *** 602,609 ****
  700.       return n - to_do;
  701.   }
  702.   
  703. ! size_t filebuf::sgetn(char *s, size_t n)
  704.   {
  705.       // FIXME: OPTIMIZE THIS (specifically, when unbuffered()).
  706. !     return streambuf::sgetn(s, n);
  707.   }
  708. --- 622,632 ----
  709.       return n - to_do;
  710.   }
  711.   
  712. ! _G_size_t filebuf::xsgetn(char *s, _G_size_t n)
  713.   {
  714.       // FIXME: OPTIMIZE THIS (specifically, when unbuffered()).
  715. !     return streambuf::xsgetn(s, n);
  716.   }
  717. + // Non-ANSI AT&T-ism:  Default open protection.
  718. + const int filebuf::openprot = 0644;
  719. *** 1.3    1992/07/17 18:24:43
  720. --- fstream.cc    1993/02/22 17:06:32
  721. ***************
  722. *** 22,59 ****
  723.   #pragma implementation
  724.   #endif
  725.   
  726. ! ifstream::ifstream()
  727.   {
  728. !     _strbuf = new filebuf();
  729.   }
  730.   
  731. ! ifstream::ifstream(int fd)
  732.   {
  733. !     _strbuf = new filebuf(fd);
  734.   }
  735.   
  736. ! ifstream::ifstream(const char *name, int mode, int prot)
  737.   {
  738. !     _strbuf = new filebuf();
  739.       if (!rdbuf()->open(name, mode, prot))
  740.       set(ios::badbit);
  741.   }
  742.   
  743. ! ofstream::ofstream()
  744.   {
  745. !     _strbuf = new filebuf();
  746. ! }
  747. ! ofstream::ofstream(int fd)
  748. ! {
  749. !     _strbuf = new filebuf(fd);
  750.   }
  751.   
  752. ! ofstream::ofstream(const char *name, int mode, int prot)
  753.   {
  754. !     _strbuf = new filebuf();
  755. !     if (!rdbuf()->open(name, mode, prot))
  756. !     set(ios::badbit);
  757.   }
  758.   
  759.   #if 0
  760. --- 22,55 ----
  761.   #pragma implementation
  762.   #endif
  763.   
  764. ! fstreambase::fstreambase()
  765.   {
  766. !     init(new filebuf());
  767.   }
  768.   
  769. ! fstreambase::fstreambase(int fd)
  770.   {
  771. !     init(new filebuf(fd));
  772.   }
  773.   
  774. ! fstreambase::fstreambase(const char *name, int mode, int prot)
  775.   {
  776. !     init(new filebuf());
  777.       if (!rdbuf()->open(name, mode, prot))
  778.       set(ios::badbit);
  779.   }
  780.   
  781. ! void fstreambase::open(const char *name, int mode, int prot)
  782.   {
  783. !     clear();
  784. !     if (!rdbuf()->open(name, mode, prot))
  785. !     set(ios::badbit);
  786.   }
  787.   
  788. ! void fstreambase::close()
  789.   {
  790. !     if (!rdbuf()->close())
  791. !     set(ios::failbit);
  792.   }
  793.   
  794.   #if 0
  795. ***************
  796. *** 67,119 ****
  797.       return "w";
  798.   }
  799.   #endif
  800. - void ifstream::open(const char *name, int mode, int prot)
  801. - {
  802. -     if (!rdbuf()->open(name, mode, prot))
  803. -     set(ios::badbit);
  804. - }
  805. - void ifstream::close()
  806. - {
  807. -     rdbuf()->close();
  808. - }
  809. - void ofstream::close()
  810. - {
  811. -     rdbuf()->close();
  812. - }
  813. - void ofstream::open(const char *name, int mode, int prot)
  814. - {
  815. -     if (!rdbuf()->open(name, mode, prot))
  816. -     set(ios::badbit);
  817. - }
  818. - fstream::fstream()
  819. - {
  820. -     _strbuf = new filebuf();
  821. - }
  822. - fstream::fstream(int fd)
  823. - {
  824. -     _strbuf = new filebuf(fd);
  825. - }
  826. - fstream::fstream(const char *name, int mode, int prot=0664)
  827. - {
  828. -     _strbuf = new filebuf();
  829. -     if (!rdbuf()->open(name, mode, prot))
  830. -     set(ios::badbit);
  831. - }
  832. - void fstream::open(const char *name, int mode, int prot=0664)
  833. - {
  834. -     if (!rdbuf()->open(name, mode, prot))
  835. -     set(ios::badbit);
  836. - }
  837. - void fstream::close()
  838. - {
  839. -     rdbuf()->close();
  840. - }
  841. --- 63,65 ----
  842. *** 1.3    1992/07/20 22:21:08
  843. --- igetline.cc    1993/02/22 17:06:33
  844. ***************
  845. *** 17,41 ****
  846.   
  847.   #include <iostream.h>
  848.   
  849. ! istream& istream::getline(char* buf, int len, char delim)
  850.   {
  851.       _gcount = 0;
  852.       if (ipfx1()) {
  853. !     long count = rdbuf()->sgetline(buf, len, delim, 0);
  854. !     _gcount = count;
  855. !     if (count <= 0 || count == len-1)
  856.           set(ios::failbit);
  857.       }
  858.       return *this;
  859.   }
  860.   
  861. ! istream& istream::get(char* buf, int len, char delim)
  862.   {
  863.       _gcount = 0;
  864.       if (ipfx1()) {
  865. !     long count = rdbuf()->sgetline(buf, len, delim, -1);
  866. !     if (count <= 0)
  867. !         set(ios::failbit);
  868.       else
  869.           _gcount = count;
  870.       }
  871. --- 17,52 ----
  872.   
  873.   #include <iostream.h>
  874.   
  875. ! istream& istream::getline(char* buf, _G_size_t len, char delim)
  876.   {
  877.       _gcount = 0;
  878.       if (ipfx1()) {
  879. !     streambuf *sb = rdbuf();
  880. !     long count = sb->sgetline(buf, len, delim, -1);
  881. !     if (count == len-1)
  882.           set(ios::failbit);
  883. +     else {
  884. +         int ch = sb->sbumpc();
  885. +         if (ch == EOF)
  886. +         set(ios::failbit|ios::eofbit);
  887. +         else if (ch == (unsigned char)delim)
  888. +         count++;
  889. +         else
  890. +         sb->sungetc(); // Leave delimiter unread.
  891. +     }
  892. +     _gcount = count;
  893.       }
  894.       return *this;
  895.   }
  896.   
  897. ! istream& istream::get(char* buf, _G_size_t len, char delim)
  898.   {
  899.       _gcount = 0;
  900.       if (ipfx1()) {
  901. !     streambuf *sbuf = rdbuf();
  902. !     long count = sbuf->sgetline(buf, len, delim, -1);
  903. !     if (count < 0 || (count == 0 && sbuf->sgetc() == EOF))
  904. !         set(ios::failbit|ios::eofbit);
  905.       else
  906.           _gcount = count;
  907.       }
  908. *** 1.1    1992/03/22 07:42:32
  909. --- indstrea.cc    1993/02/22 17:06:34
  910. ***************
  911. *** 35,51 ****
  912.       if (_delete_flags & ios::out)  delete put_stream();
  913.   }
  914.   
  915. ! int indirectbuf::sputn(const char* s, int n)
  916.   {
  917.       return put_stream()->sputn(s, n);
  918.   }
  919.   
  920. ! int indirectbuf::sgetn(char* s, int n)
  921.   {
  922.       return get_stream()->sgetn(s, n);
  923.   }
  924.   
  925. ! int indirectbuf::overflow(int c = EOF)
  926.   {
  927.       if (c == EOF)
  928.       return put_stream()->overflow(c);
  929. --- 35,51 ----
  930.       if (_delete_flags & ios::out)  delete put_stream();
  931.   }
  932.   
  933. ! _G_size_t indirectbuf::xsputn(const char* s, _G_size_t n)
  934.   {
  935.       return put_stream()->sputn(s, n);
  936.   }
  937.   
  938. ! _G_size_t indirectbuf::xsgetn(char* s, _G_size_t n)
  939.   {
  940.       return get_stream()->sgetn(s, n);
  941.   }
  942.   
  943. ! int indirectbuf::overflow(int c /* = EOF */)
  944.   {
  945.       if (c == EOF)
  946.       return put_stream()->overflow(c);
  947. ***************
  948. *** 105,113 ****
  949.   int indirectbuf::pbackfail(int c)
  950.   {
  951.       return get_stream()->sputbackc(c);
  952. - }
  953. - int indirectbuf::ungetfail()
  954. - {
  955. -     return get_stream()->sungetc();
  956.   }
  957. --- 105,108 ----
  958. *** 1.2    1992/07/20 22:21:08
  959. --- iodtoa.cc    1993/02/22 17:06:34
  960. ***************
  961. *** 275,281 ****
  962.   
  963.   #define Kmax 15
  964.   
  965. ! extern "C" double strtod(const char *s00, char **se);
  966.   extern "C" char *dtoa(double d, int mode, int ndigits,
  967.                           int *decpt, int *sign, char **rve);
  968.   
  969. --- 275,281 ----
  970.   
  971.   #define Kmax 15
  972.   
  973. ! extern "C" double _Xstrtod(const char *s00, char **se);
  974.   extern "C" char *dtoa(double d, int mode, int ndigits,
  975.                           int *decpt, int *sign, char **rve);
  976.   
  977. ***************
  978. *** 1123,1129 ****
  979.   #endif
  980.   
  981.    double
  982. ! strtod
  983.   #ifdef KR_headers
  984.           (s00, se) CONST char *s00; char **se;
  985.   #else
  986. --- 1123,1129 ----
  987.   #endif
  988.   
  989.    double
  990. ! _Xstrtod
  991.   #ifdef KR_headers
  992.           (s00, se) CONST char *s00; char **se;
  993.   #else
  994. ***************
  995. *** 2397,2403 ****
  996.   #ifdef atarist
  997.   double atof(const char *s)
  998.   {
  999. !     return strtod(s, (char **)NULL);
  1000.   }
  1001.   #endif
  1002.   
  1003. --- 2397,2403 ----
  1004.   #ifdef atarist
  1005.   double atof(const char *s)
  1006.   {
  1007. !     return _Xstrtod(s, (char **)NULL);
  1008.   }
  1009.   #endif
  1010.   
  1011. *** 1.8    1992/12/11 19:39:04
  1012. --- iostream.cc    1993/02/22 17:06:35
  1013. ***************
  1014. *** 1,5 ****
  1015.   //    This is part of the iostream library, providing input/output for C++.
  1016. ! //    Copyright (C) 1991 Per Bothner.
  1017.   //
  1018.   //    This library is free software; you can redistribute it and/or
  1019.   //    modify it under the terms of the GNU Library General Public
  1020. --- 1,5 ----
  1021.   //    This is part of the iostream library, providing input/output for C++.
  1022. ! //    Copyright (C) 1991, 1992 Per Bothner.
  1023.   //
  1024.   //    This library is free software; you can redistribute it and/or
  1025.   //    modify it under the terms of the GNU Library General Public
  1026. ***************
  1027. *** 23,28 ****
  1028. --- 23,29 ----
  1029.   #include <iostream.h>
  1030.   #include <stdio.h>  /* Needed for sprintf */
  1031.   #include <ctype.h>
  1032. + #include <limits.h>
  1033.   #include <floatio.h>
  1034.   
  1035.   #define    BUF        (MAXEXP+MAXFRACT+1)    /* + decimal point */
  1036. ***************
  1037. *** 29,36 ****
  1038.   
  1039.   //#define isspace(ch) ((ch)==' ' || (ch)=='\t' || (ch)=='\n')
  1040.   
  1041. - extern backupbuf not_open_filebuf;
  1042.   istream::istream(streambuf *sb, ostream* tied) : ios(sb, tied)
  1043.   {
  1044.       _flags |= ios::dont_close;
  1045. --- 30,35 ----
  1046. ***************
  1047. *** 57,64 ****
  1048.       return *this;
  1049.   }
  1050.   
  1051. ! istream& istream::ignore(int n=1, int delim = EOF)
  1052.   {
  1053.       if (ipfx1()) {
  1054.       register streambuf* sb = _strbuf;
  1055.       if (delim == EOF) {
  1056. --- 56,64 ----
  1057.       return *this;
  1058.   }
  1059.   
  1060. ! istream& istream::ignore(_G_size_t n1 /* = 1 */, int delim /* = EOF */)
  1061.   {
  1062. +     long n = n1;
  1063.       if (ipfx1()) {
  1064.       register streambuf* sb = _strbuf;
  1065.       if (delim == EOF) {
  1066. ***************
  1067. *** 85,91 ****
  1068.       return *this;
  1069.   }
  1070.   
  1071. ! istream& istream::read(char *s, size_t n)
  1072.   {
  1073.       if (ipfx1()) {
  1074.       _gcount = _strbuf->sgetn(s, n);
  1075. --- 85,91 ----
  1076.       return *this;
  1077.   }
  1078.   
  1079. ! istream& istream::read(char *s, _G_size_t n)
  1080.   {
  1081.       if (ipfx1()) {
  1082.       _gcount = _strbuf->sgetn(s, n);
  1083. ***************
  1084. *** 124,130 ****
  1085.       if (ipfx0()) {
  1086.       va_list ap;
  1087.       va_start(ap, format);
  1088. !     _strbuf->vscan(format, ap, &_state);
  1089.       va_end(ap);
  1090.       }
  1091.       return *this;
  1092. --- 124,130 ----
  1093.       if (ipfx0()) {
  1094.       va_list ap;
  1095.       va_start(ap, format);
  1096. !     _strbuf->vscan(format, ap, this);
  1097.       va_end(ap);
  1098.       }
  1099.       return *this;
  1100. ***************
  1101. *** 133,168 ****
  1102.   istream& istream::vscan(const char *format, _G_va_list args)
  1103.   {
  1104.       if (ipfx0())
  1105. !     _strbuf->vscan(format, args, &_state);
  1106.       return *this;
  1107.   }
  1108.   
  1109. ! istream& operator>>(istream& is, char& c)
  1110.   {
  1111. !     if (is.ipfx0()) {
  1112. !     int ch = is._strbuf->sbumpc();
  1113.       if (ch == EOF)
  1114. !         is.set(ios::eofbit|ios::failbit);
  1115.       else
  1116.           c = (char)ch;
  1117.       }
  1118. !     return is;
  1119.   }
  1120.   
  1121. ! istream& operator>>(istream& is, char* ptr)
  1122.   {
  1123. !     if (is.ipfx0()) {
  1124. !     register streambuf* sb = is._strbuf;
  1125.       int ch = sb->sbumpc();
  1126.       if (ch == EOF)
  1127. !         is.set(ios::eofbit|ios::failbit);
  1128.       else {
  1129. !         int w = is.width(0);
  1130. !         *ptr++ = ch;
  1131.           for (;;) {
  1132.           ch = sb->sbumpc();
  1133.           if (ch == EOF) {
  1134. !             is.set(ios::eofbit|ios::failbit);
  1135.               break;
  1136.           }
  1137.           else if (isspace(ch)) {
  1138. --- 133,168 ----
  1139.   istream& istream::vscan(const char *format, _G_va_list args)
  1140.   {
  1141.       if (ipfx0())
  1142. !     _strbuf->vscan(format, args, this);
  1143.       return *this;
  1144.   }
  1145.   
  1146. ! istream& istream::operator>>(char& c)
  1147.   {
  1148. !     if (ipfx0()) {
  1149. !     int ch = _strbuf->sbumpc();
  1150.       if (ch == EOF)
  1151. !         set(ios::eofbit|ios::failbit);
  1152.       else
  1153.           c = (char)ch;
  1154.       }
  1155. !     return *this;
  1156.   }
  1157.   
  1158. ! istream& istream::operator>>(char* ptr)
  1159.   {
  1160. !     if (ipfx0()) {
  1161. !     register streambuf* sb = _strbuf;
  1162.       int ch = sb->sbumpc();
  1163.       if (ch == EOF)
  1164. !         set(ios::eofbit|ios::failbit);
  1165.       else {
  1166. !         int w = width(0);
  1167. !         sb->sputbackc(ch);
  1168.           for (;;) {
  1169.           ch = sb->sbumpc();
  1170.           if (ch == EOF) {
  1171. !             set(ios::eofbit);
  1172.               break;
  1173.           }
  1174.           else if (isspace(ch)) {
  1175. ***************
  1176. *** 170,176 ****
  1177.               break;
  1178.           }
  1179.           else if (w == 1) {
  1180. !             is.set(ios::failbit);
  1181.               sb->sputbackc(ch);
  1182.               break;
  1183.           }
  1184. --- 170,176 ----
  1185.               break;
  1186.           }
  1187.           else if (w == 1) {
  1188. !             set(ios::failbit);
  1189.               sb->sputbackc(ch);
  1190.               break;
  1191.           }
  1192. ***************
  1193. *** 180,189 ****
  1194.       }
  1195.       }
  1196.       *ptr = '\0';
  1197. !     return is;
  1198.   }
  1199.   
  1200. ! static int read_int(istream& stream, unsigned long& val, int& neg)
  1201.   {
  1202.       if (!stream.ipfx0())
  1203.       return 0;
  1204. --- 180,195 ----
  1205.       }
  1206.       }
  1207.       *ptr = '\0';
  1208. !     return *this;
  1209.   }
  1210.   
  1211. ! #if defined(__GNUC__) && (!defined(atarist))
  1212. ! #define LONGEST long long
  1213. ! #else
  1214. ! #define LONGEST long
  1215. ! #endif
  1216. ! static int read_int(istream& stream, unsigned LONGEST& val, int& neg)
  1217.   {
  1218.       if (!stream.ipfx0())
  1219.       return 0;
  1220. ***************
  1221. *** 202,208 ****
  1222.       ch = skip_ws(sb);
  1223.       }
  1224.       if (ch == EOF) goto eof_fail;
  1225. !     if (!(stream.flags() & (ios::hex|ios::dec|ios::oct))) {
  1226.       if (ch == '0') {
  1227.           ch = sb->sbumpc();
  1228.           if (ch == EOF) {
  1229. --- 208,214 ----
  1230.       ch = skip_ws(sb);
  1231.       }
  1232.       if (ch == EOF) goto eof_fail;
  1233. !     if (!(stream.flags() & ios::basefield)) {
  1234.       if (ch == '0') {
  1235.           ch = sb->sbumpc();
  1236.           if (ch == EOF) {
  1237. ***************
  1238. *** 221,229 ****
  1239.           }
  1240.       }
  1241.       }
  1242. !     else if (stream.flags() & ios::hex)
  1243.       base = 16;
  1244. !     else if (stream.flags() & ios::oct)
  1245.       base = 8;
  1246.       val = 0;
  1247.       for (;;) {
  1248. --- 227,235 ----
  1249.           }
  1250.       }
  1251.       }
  1252. !     else if ((stream.flags() & ios::basefield) == ios::hex)
  1253.       base = 16;
  1254. !     else if ((stream.flags() & ios::basefield) == ios::oct)
  1255.       base = 8;
  1256.       val = 0;
  1257.       for (;;) {
  1258. ***************
  1259. *** 259,272 ****
  1260.   }
  1261.   
  1262.   #define READ_INT(TYPE) \
  1263. ! istream& operator>>(istream& is, TYPE& i)\
  1264.   {\
  1265. !     unsigned long val; int neg;\
  1266. !     if (read_int(is, val, neg)) {\
  1267.       if (neg) val = -val;\
  1268.       i = (TYPE)val;\
  1269.       }\
  1270. !     return is;\
  1271.   }
  1272.   
  1273.   READ_INT(short)
  1274. --- 265,278 ----
  1275.   }
  1276.   
  1277.   #define READ_INT(TYPE) \
  1278. ! istream& istream::operator>>(TYPE& i)\
  1279.   {\
  1280. !     unsigned LONGEST val; int neg;\
  1281. !     if (read_int(*this, val, neg)) {\
  1282.       if (neg) val = -val;\
  1283.       i = (TYPE)val;\
  1284.       }\
  1285. !     return *this;\
  1286.   }
  1287.   
  1288.   READ_INT(short)
  1289. ***************
  1290. *** 275,365 ****
  1291.   READ_INT(unsigned int)
  1292.   READ_INT(long)
  1293.   READ_INT(unsigned long)
  1294.   
  1295. ! istream& operator>>(istream& is, double& x)
  1296.   {
  1297. !     if (is.ipfx0()) {
  1298. !     is.scan("%lg", &x);
  1299. !     }
  1300. !     return is;
  1301.   }
  1302. ! istream& operator>>(istream& is, float& x)
  1303.   {
  1304. !     if (is.ipfx0()) {
  1305. !     is.scan("%g", &x);
  1306. !     }
  1307. !     return is;
  1308.   }
  1309.   
  1310. ! istream& operator>>(istream& is, register streambuf* sbuf)
  1311.   {
  1312. !     if (is.ipfx0()) {
  1313. !     register streambuf* inbuf = is.rdbuf();
  1314.       // FIXME: Should optimize!
  1315.       for (;;) {
  1316.           register int ch = inbuf->sbumpc();
  1317.           if (ch == EOF) {
  1318. !         is.set(ios::eofbit);
  1319.           break;
  1320.           }
  1321.           if (sbuf->sputc(ch) == EOF) {
  1322. !         is.set(ios::failbit);
  1323.           break;
  1324.           }
  1325.       }
  1326.       }
  1327. !     return is;
  1328.   }
  1329.   
  1330. ! ostream& operator<<(ostream& os, char c)
  1331.   {
  1332. !     if (os.opfx()) {
  1333. !     int w = os.width(0);
  1334. !     char fill_char = os.fill();
  1335.       register int padding = w > 0 ? w - 1 : 0;
  1336. !     register streambuf *sb = os._strbuf;
  1337. !     if (!(os.flags() & ios::left)) // Default adjustment.
  1338.           while (--padding >= 0) sb->sputc(fill_char);
  1339.       sb->sputc(c);
  1340. !     if (os.flags() & ios::left) // Left adjustment.
  1341.           while (--padding >= 0) sb->sputc(fill_char);
  1342. !     os.osfx();
  1343.       }
  1344. !     return os;
  1345.   }
  1346.   
  1347. ! void write_int(ostream& stream, unsigned long val, int neg)
  1348.   {
  1349. !     char buf[10 + sizeof(unsigned long) * 3];
  1350.       char *show_base = "";
  1351.       int show_base_len = 0;
  1352. !     if ((stream.flags() & (ios::oct|ios::hex)) == 0) // Decimal
  1353. !     sprintf(buf, "%lu", val);
  1354. !     else if (stream.flags() & ios::oct) { // Oct
  1355. !     sprintf(buf, "%lo", val);
  1356. !     if (stream.flags() & ios::showbase)
  1357.           show_base = "0", show_base_len = 1;
  1358.       }
  1359. !     else if (stream.flags() & ios::uppercase) {// Hex
  1360. !     sprintf(buf, "%lX", val);
  1361. !     if (stream.flags() & ios::showbase)
  1362. !         show_base = "0X", show_base_len = 2;
  1363. !     }
  1364. !     else { // Hex
  1365. !     sprintf(buf, "%lx", val);
  1366. !     if (stream.flags() & ios::showbase)
  1367. !         show_base = "0x", show_base_len = 2;
  1368.       }
  1369. !     int buf_len = strlen(buf);
  1370.       int w = stream.width(0);
  1371. -     int show_pos = 0;
  1372.   
  1373.       // Calculate padding.
  1374. !     int len = buf_len;
  1375. !     if (neg) len++;
  1376. !     else if (val != 0 && (stream.flags() & ios::showpos)) len++, show_pos=1;
  1377.       len += show_base_len;
  1378. !     int padding = len > w ? 0 : w - len;
  1379.   
  1380.       // Do actual output.
  1381.       register streambuf* sbuf = stream.rdbuf();
  1382. --- 281,407 ----
  1383.   READ_INT(unsigned int)
  1384.   READ_INT(long)
  1385.   READ_INT(unsigned long)
  1386. + #ifdef __GNUG__
  1387. + READ_INT(long long)
  1388. + READ_INT(unsigned long long)
  1389. + #endif
  1390.   
  1391. ! istream& istream::operator>>(double& x)
  1392.   {
  1393. !     if (ipfx0())
  1394. !     scan("%lg", &x);
  1395. !     return *this;
  1396.   }
  1397. ! istream& istream::operator>>(float& x)
  1398.   {
  1399. !     if (ipfx0())
  1400. !     scan("%g", &x);
  1401. !     return *this;
  1402.   }
  1403.   
  1404. ! istream& istream::operator>>(register streambuf* sbuf)
  1405.   {
  1406. !     if (ipfx0()) {
  1407. !     register streambuf* inbuf = rdbuf();
  1408.       // FIXME: Should optimize!
  1409.       for (;;) {
  1410.           register int ch = inbuf->sbumpc();
  1411.           if (ch == EOF) {
  1412. !         set(ios::eofbit);
  1413.           break;
  1414.           }
  1415.           if (sbuf->sputc(ch) == EOF) {
  1416. !         set(ios::failbit);
  1417.           break;
  1418.           }
  1419.       }
  1420.       }
  1421. !     return *this;
  1422.   }
  1423.   
  1424. ! ostream& ostream::operator<<(char c)
  1425.   {
  1426. !     if (opfx()) {
  1427. !     int w = width(0);
  1428. !     char fill_char = fill();
  1429.       register int padding = w > 0 ? w - 1 : 0;
  1430. !     register streambuf *sb = _strbuf;
  1431. !     if (!(flags() & ios::left)) // Default adjustment.
  1432.           while (--padding >= 0) sb->sputc(fill_char);
  1433.       sb->sputc(c);
  1434. !     if (flags() & ios::left) // Left adjustment.
  1435.           while (--padding >= 0) sb->sputc(fill_char);
  1436. !     osfx();
  1437.       }
  1438. !     return *this;
  1439.   }
  1440.   
  1441. ! /* Write VAL on STREAM.
  1442. !    If SIGN<0, val is the absolute value of a negative number.
  1443. !    If SIGN>0, val is a signed non-negative number.
  1444. !    If SIGN==0, val is unsigned. */
  1445. ! static void write_int(ostream& stream, unsigned LONGEST val, int sign)
  1446.   {
  1447. ! #define WRITE_BUF_SIZE (10 + sizeof(unsigned LONGEST) * 3)
  1448. !     char buf[WRITE_BUF_SIZE];
  1449. !     register char *buf_ptr = buf+WRITE_BUF_SIZE; // End of buf.
  1450.       char *show_base = "";
  1451.       int show_base_len = 0;
  1452. !     int show_pos = 0; // If 1, print a '+'.
  1453. !     // Now do the actual conversion, placing the result at the *end* of buf.
  1454. !     // Note that we use separate code for decimal, octal, and hex,
  1455. !     // so we can divide by optimizable constants.
  1456. !     if ((stream.flags() & ios::basefield) == ios::oct) { // Octal
  1457. !     if ((stream.flags() & ios::showbase) && (val != 0))
  1458.           show_base = "0", show_base_len = 1;
  1459. +     do {
  1460. +         *--buf_ptr = (val & 7) + '0';
  1461. +         val = val >> 3;
  1462. +     } while (val != 0);
  1463. +     }
  1464. +     else if ((stream.flags() & ios::basefield) == ios::hex) { // Hex
  1465. +     char *xdigs = (stream.flags() & ios::uppercase) ? "0123456789ABCDEF0X"
  1466. +         : "0123456789abcdef0x";
  1467. +     do {
  1468. +         *--buf_ptr = xdigs[val & 15];
  1469. +         val = val >> 4;
  1470. +     } while (val != 0);
  1471. +     if (stream.flags() & ios::showbase) {
  1472. +         show_base = xdigs + 16; // Either "0X" or "0x".
  1473. +         show_base_len = 2;
  1474. +     }
  1475.       }
  1476. !     else { // Decimal
  1477. !     if (val != 0 && sign > 0 && (stream.flags() & ios::showpos))
  1478. !         show_pos=1;
  1479. ! #ifdef __GNUC__
  1480. !     // Optimization:  Only use long long when we need to.
  1481. !     while (val > UINT_MAX) {
  1482. !         *--buf_ptr = (val % 10) + '0';
  1483. !         val /= 10;
  1484. !     }
  1485. !     // Use more efficient (int) arithmetic for the rest.
  1486. !     register unsigned int ival = (unsigned int)val;
  1487. ! #else
  1488. !     register unsigned LONGEST ival = val;
  1489. ! #endif
  1490. !     do {
  1491. !         *--buf_ptr = (ival % 10) + '0';
  1492. !         ival /= 10;
  1493. !     } while (ival != 0);
  1494.       }
  1495. !     _G_size_t buf_len = buf+WRITE_BUF_SIZE - buf_ptr;
  1496.       int w = stream.width(0);
  1497.   
  1498.       // Calculate padding.
  1499. !     _G_size_t len = buf_len+show_pos;
  1500. !     if (sign < 0) len++;
  1501.       len += show_base_len;
  1502. !     _G_size_t padding = len > w ? 0 : w - len;
  1503.   
  1504.       // Do actual output.
  1505.       register streambuf* sbuf = stream.rdbuf();
  1506. ***************
  1507. *** 370,450 ****
  1508.       && pad_kind != (ios::fmtflags)ios::left
  1509.       && pad_kind != (ios::fmtflags)ios::internal) // Default (right) adjust.
  1510.       sbuf->padn(fill_char, padding);
  1511. !     if (neg) sbuf->sputc('-');
  1512.       else if (show_pos) sbuf->sputc('+');
  1513.       if (show_base_len)
  1514.       sbuf->sputn(show_base, show_base_len);
  1515.       if (pad_kind == (ios::fmtflags)ios::internal && padding > 0)
  1516.       sbuf->padn(fill_char, padding);
  1517. !     sbuf->sputn(buf, buf_len);
  1518.       if (pad_kind == (ios::fmtflags)ios::left && padding > 0) // Left adjustment
  1519.       sbuf->padn(fill_char, padding);
  1520.       stream.osfx();
  1521.   }
  1522.   
  1523. ! ostream& operator<<(ostream& os, int n)
  1524.   {
  1525. !     if (os.opfx()) {
  1526. !     int neg = 0;
  1527. !     if (n < 0 && (os.flags() & (ios::oct|ios::hex)) == 0)
  1528. !         n = -n, neg = 1;
  1529. !     write_int(os, n, neg);
  1530.       }
  1531. !     return os;
  1532.   }
  1533.   
  1534. ! ostream& operator<<(ostream& os, long n)
  1535.   {
  1536. !     if (os.opfx()) {
  1537. !     int neg = 0;
  1538. !     if (n < 0 && (os.flags() & (ios::oct|ios::hex)) == 0)
  1539. !         n = -n, neg = 1;
  1540. !     write_int(os, n, neg);
  1541.       }
  1542. !     return os;
  1543.   }
  1544.   
  1545. ! ostream& operator<<(ostream& os, unsigned int n)
  1546.   {
  1547. !     if (os.opfx())
  1548. !     write_int(os, n, 0);
  1549. !     return os;
  1550.   }
  1551.   
  1552. ! ostream& operator<<(ostream& os, unsigned long n)
  1553.   {
  1554. !     if (os.opfx())
  1555. !     write_int(os, n, 0);
  1556. !     return os;
  1557.   }
  1558.   
  1559. ! ostream& operator<<(ostream& os, float n)
  1560.   {
  1561. !     return os << (double)n;
  1562.   }
  1563.   
  1564. ! ostream& operator<<(ostream& os, double n)
  1565.   {
  1566. !     if (os.opfx()) {
  1567.       // Uses __cvt_double (renamed from static cvt), in Chris Torek's
  1568.       // stdio implementation.  The setup code uses the same logic
  1569.       // as in __vsbprintf.C (also based on Torek's code).
  1570.       int format_char;
  1571.   #if 0
  1572. !     if (os.flags() ios::showpos) sign = '+';
  1573.   #endif
  1574. !     if (os.flags() & ios::fixed)
  1575.           format_char = 'f';
  1576. !     else if (os.flags() & ios::scientific)
  1577. !         format_char = os.flags() & ios::uppercase ? 'E' : 'e';
  1578.       else
  1579. !         format_char = os.flags() & ios::uppercase ? 'G' : 'g';
  1580.   
  1581.       int fpprec = 0; // 'Extra' (suppressed) floating precision.
  1582. !     int prec = os.precision();
  1583.       if (prec < 0) prec = 6; // default.
  1584.       else if (prec > MAXFRACT) {
  1585. !         if (os.flags() & (ios::fixed|ios::scientific) & ios::showpos)
  1586.           fpprec = prec - MAXFRACT;
  1587.           prec = MAXFRACT;
  1588.       }
  1589. --- 412,509 ----
  1590.       && pad_kind != (ios::fmtflags)ios::left
  1591.       && pad_kind != (ios::fmtflags)ios::internal) // Default (right) adjust.
  1592.       sbuf->padn(fill_char, padding);
  1593. !     if (sign < 0) sbuf->sputc('-');
  1594.       else if (show_pos) sbuf->sputc('+');
  1595.       if (show_base_len)
  1596.       sbuf->sputn(show_base, show_base_len);
  1597.       if (pad_kind == (ios::fmtflags)ios::internal && padding > 0)
  1598.       sbuf->padn(fill_char, padding);
  1599. !     sbuf->sputn(buf_ptr, buf_len);
  1600.       if (pad_kind == (ios::fmtflags)ios::left && padding > 0) // Left adjustment
  1601.       sbuf->padn(fill_char, padding);
  1602.       stream.osfx();
  1603.   }
  1604.   
  1605. ! ostream& ostream::operator<<(int n)
  1606.   {
  1607. !     if (opfx()) {
  1608. !     int sign = 1;
  1609. !     if (n < 0 && (flags() & (ios::oct|ios::hex)) == 0)
  1610. !         n = -n, sign = -1;
  1611. !     write_int(*this, n, sign);
  1612.       }
  1613. !     return *this;
  1614. ! }
  1615. ! ostream& ostream::operator<<(unsigned int n)
  1616. ! {
  1617. !     if (opfx())
  1618. !     write_int(*this, n, 0);
  1619. !     return *this;
  1620.   }
  1621.   
  1622. ! ostream& ostream::operator<<(long n)
  1623.   {
  1624. !     if (opfx()) {
  1625. !     int sign = 1;
  1626. !     if (n < 0 && (flags() & (ios::oct|ios::hex)) == 0)
  1627. !         n = -n, sign = -1;
  1628. !     write_int(*this, n, sign);
  1629.       }
  1630. !     return *this;
  1631.   }
  1632.   
  1633. ! ostream& ostream::operator<<(unsigned long n)
  1634.   {
  1635. !     if (opfx())
  1636. !     write_int(*this, n, 0);
  1637. !     return *this;
  1638.   }
  1639.   
  1640. ! #ifdef __GNUG__
  1641. ! ostream& ostream::operator<<(long long n)
  1642.   {
  1643. !     if (opfx()) {
  1644. !     int sign = 1;
  1645. !     if (n < 0 && (flags() & (ios::oct|ios::hex)) == 0)
  1646. !         n = -n, sign = -1;
  1647. !     write_int(*this, n, sign);
  1648. !     }
  1649. !     return *this;
  1650.   }
  1651.   
  1652. ! ostream& ostream::operator<<(unsigned long long n)
  1653.   {
  1654. !     if (opfx())
  1655. !     write_int(*this, n, 0);
  1656. !     return *this;
  1657.   }
  1658. + #endif /*__GNUG__*/
  1659.   
  1660. ! ostream& ostream::operator<<(double n)
  1661.   {
  1662. !     if (opfx()) {
  1663.       // Uses __cvt_double (renamed from static cvt), in Chris Torek's
  1664.       // stdio implementation.  The setup code uses the same logic
  1665.       // as in __vsbprintf.C (also based on Torek's code).
  1666.       int format_char;
  1667.   #if 0
  1668. !     if (flags() ios::showpos) sign = '+';
  1669.   #endif
  1670. !     if ((flags() & ios::floatfield) == ios::fixed)
  1671.           format_char = 'f';
  1672. !     else if ((flags() & ios::floatfield) == ios::scientific)
  1673. !         format_char = flags() & ios::uppercase ? 'E' : 'e';
  1674.       else
  1675. !         format_char = flags() & ios::uppercase ? 'G' : 'g';
  1676.   
  1677.       int fpprec = 0; // 'Extra' (suppressed) floating precision.
  1678. !     int prec = precision();
  1679.       if (prec < 0) prec = 6; // default.
  1680.       else if (prec > MAXFRACT) {
  1681. !         if (flags() & (ios::fixed|ios::scientific) & ios::showpos)
  1682.           fpprec = prec - MAXFRACT;
  1683.           prec = MAXFRACT;
  1684.       }
  1685. ***************
  1686. *** 451,459 ****
  1687.   
  1688.       // Do actual conversion.
  1689.   #ifdef USE_DTOA
  1690. !     if (__outfloat(n, os.rdbuf(), format_char, os.width(0),
  1691. !                os.precision(), os.flags(), 0, os.fill()) < 0)
  1692. !         os.set(ios::badbit|ios::failbit); // ??
  1693.   #else
  1694.       int negative;
  1695.       char buf[BUF];
  1696. --- 510,518 ----
  1697.   
  1698.       // Do actual conversion.
  1699.   #ifdef USE_DTOA
  1700. !     if (__outfloat(n, rdbuf(), format_char, width(0),
  1701. !                precision(), flags(), 0, fill()) < 0)
  1702. !         set(ios::badbit|ios::failbit); // ??
  1703.   #else
  1704.       int negative;
  1705.       char buf[BUF];
  1706. ***************
  1707. *** 460,467 ****
  1708.       int sign = '\0';
  1709.       char *cp = buf;
  1710.       *cp = 0;
  1711. !     int size = __cvt_double(n, os.precision(),
  1712. !                 os.flags() & ios::showpoint ? 0x80 : 0,
  1713.                   &negative,
  1714.                   format_char, cp, buf + sizeof(buf));
  1715.       if (negative) sign = '-';
  1716. --- 519,526 ----
  1717.       int sign = '\0';
  1718.       char *cp = buf;
  1719.       *cp = 0;
  1720. !     int size = __cvt_double(n, precision(),
  1721. !                 flags() & ios::showpoint ? 0x80 : 0,
  1722.                   &negative,
  1723.                   format_char, cp, buf + sizeof(buf));
  1724.       if (negative) sign = '-';
  1725. ***************
  1726. *** 472,487 ****
  1727.       int fieldsize = size + fpprec;
  1728.       if (sign) fieldsize++;
  1729.       int padding = 0;
  1730. !     int w = os.width(0);
  1731.       if (fieldsize < w)
  1732.           padding = w - fieldsize;
  1733.   
  1734.       // Do actual output.
  1735. !     register streambuf* sbuf = os.rdbuf();
  1736.       register i;
  1737. !     char fill_char = os.fill();
  1738.       ios::fmtflags pad_kind =
  1739. !         os.flags() & (ios::left|ios::right|ios::internal);
  1740.       if (pad_kind != (ios::fmtflags)ios::left // Default (right) adjust.
  1741.           && pad_kind != (ios::fmtflags)ios::internal)
  1742.           for (i = padding; --i >= 0; ) sbuf->sputc(fill_char);
  1743. --- 531,546 ----
  1744.       int fieldsize = size + fpprec;
  1745.       if (sign) fieldsize++;
  1746.       int padding = 0;
  1747. !     int w = width(0);
  1748.       if (fieldsize < w)
  1749.           padding = w - fieldsize;
  1750.   
  1751.       // Do actual output.
  1752. !     register streambuf* sbuf = rdbuf();
  1753.       register i;
  1754. !     char fill_char = fill();
  1755.       ios::fmtflags pad_kind =
  1756. !         flags() & (ios::left|ios::right|ios::internal);
  1757.       if (pad_kind != (ios::fmtflags)ios::left // Default (right) adjust.
  1758.           && pad_kind != (ios::fmtflags)ios::internal)
  1759.           for (i = padding; --i >= 0; ) sbuf->sputc(fill_char);
  1760. ***************
  1761. *** 497,550 ****
  1762.       if (pad_kind == (ios::fmtflags)ios::left) // Left adjustment
  1763.           for (i = padding; --i >= 0; ) sbuf->sputc(fill_char);
  1764.   #endif
  1765. !     os.osfx();
  1766.       }
  1767. !     return os;
  1768.   }
  1769.   
  1770. ! ostream& operator<<(ostream& stream, const char *s)
  1771.   {
  1772. !     if (stream.opfx()) {
  1773. !     size_t len = strlen(s);
  1774. !     int w = stream.width(0);
  1775. !     char fill_char = stream.fill();
  1776. !     register streambuf *sbuf = stream.rdbuf();
  1777.       register int padding = w > len ? w - len : 0;
  1778. !     if (!(stream.flags() & ios::left)) // Default adjustment.
  1779.           while (--padding >= 0) sbuf->sputc(fill_char);
  1780.       sbuf->sputn(s, len);
  1781. !     if (stream.flags() & ios::left) // Left adjustment.
  1782.           while (--padding >= 0) sbuf->sputc(fill_char);
  1783. !     stream.osfx();
  1784.       }
  1785. !     return stream;
  1786.   }
  1787.   
  1788. ! ostream& operator<<(ostream& os, void *p)
  1789.   {
  1790. !     if (os.opfx()) {
  1791. !     os.form("%p", p);
  1792. !     os.osfx();
  1793.       }
  1794. !     return os;
  1795.   }
  1796.   
  1797. ! ostream& operator<<(ostream& os, register streambuf* sbuf)
  1798.   {
  1799. !     if (os.opfx()) {
  1800. !     register streambuf* outbuf = os.rdbuf();
  1801.       // FIXME: Should optimize!
  1802.       for (;;) {
  1803.           register int ch = sbuf->sbumpc();
  1804.           if (ch == EOF) break;
  1805.           if (outbuf->sputc(ch) == EOF) {
  1806. !         os.set(ios::badbit);
  1807.           break;
  1808.           }
  1809.       }
  1810. !     os.osfx();
  1811.       }
  1812. !     return os;
  1813.   }
  1814.   
  1815.   ostream::ostream(streambuf* sb, ostream* tied) : ios(sb, tied)
  1816. --- 556,611 ----
  1817.       if (pad_kind == (ios::fmtflags)ios::left) // Left adjustment
  1818.           for (i = padding; --i >= 0; ) sbuf->sputc(fill_char);
  1819.   #endif
  1820. !     osfx();
  1821.       }
  1822. !     return *this;
  1823.   }
  1824.   
  1825. ! ostream& ostream::operator<<(const char *s)
  1826.   {
  1827. !     if (opfx()) {
  1828. !     if (s == NULL)
  1829. !         s = "(null)";
  1830. !     _G_size_t len = strlen(s);
  1831. !     int w = width(0);
  1832. !     char fill_char = fill();
  1833. !     register streambuf *sbuf = rdbuf();
  1834.       register int padding = w > len ? w - len : 0;
  1835. !     if (!(flags() & ios::left)) // Default adjustment.
  1836.           while (--padding >= 0) sbuf->sputc(fill_char);
  1837.       sbuf->sputn(s, len);
  1838. !     if (flags() & ios::left) // Left adjustment.
  1839.           while (--padding >= 0) sbuf->sputc(fill_char);
  1840. !     osfx();
  1841.       }
  1842. !     return *this;
  1843.   }
  1844.   
  1845. ! ostream& ostream::operator<<(void *p)
  1846.   {
  1847. !     if (opfx()) {
  1848. !     form("%p", p);
  1849. !     osfx();
  1850.       }
  1851. !     return *this;
  1852.   }
  1853.   
  1854. ! ostream& ostream::operator<<(register streambuf* sbuf)
  1855.   {
  1856. !     if (opfx()) {
  1857. !     register streambuf* outbuf = rdbuf();
  1858.       // FIXME: Should optimize!
  1859.       for (;;) {
  1860.           register int ch = sbuf->sbumpc();
  1861.           if (ch == EOF) break;
  1862.           if (outbuf->sputc(ch) == EOF) {
  1863. !         set(ios::badbit);
  1864.           break;
  1865.           }
  1866.       }
  1867. !     osfx();
  1868.       }
  1869. !     return *this;
  1870.   }
  1871.   
  1872.   ostream::ostream(streambuf* sb, ostream* tied) : ios(sb, tied)
  1873. ***************
  1874. *** 647,653 ****
  1875.       return flush(outs.put('\n'));
  1876.   }
  1877.   
  1878. ! ostream& ostream::write(const char *s, size_t n)
  1879.   {
  1880.       if (opfx()) {
  1881.       if (_strbuf->sputn(s, n) != n)
  1882. --- 708,714 ----
  1883.       return flush(outs.put('\n'));
  1884.   }
  1885.   
  1886. ! ostream& ostream::write(const char *s, _G_size_t n)
  1887.   {
  1888.       if (opfx()) {
  1889.       if (_strbuf->sputn(s, n) != n)
  1890. ***************
  1891. *** 666,676 ****
  1892.       }
  1893.   }
  1894.   
  1895. - const unsigned long ios::basefield = ios::hex|ios::oct|ios::dec;
  1896. - const unsigned long ios::floatfield = ios::scientific|ios::fixed;
  1897. - const unsigned long ios::adjustfield =
  1898. -     ios::left|ios::right|ios::internal;
  1899.   iostream::iostream(streambuf* sb, ostream* tied) : ios(sb, tied)
  1900.   {
  1901.       _flags |= ios::dont_close;
  1902. --- 727,732 ----
  1903. ***************
  1904. *** 677,701 ****
  1905.       _gcount = 0;
  1906.   }
  1907.   
  1908. - ostream& iostream::form(const char *format ...) // Copy of ostream::form.
  1909. - {
  1910. -     va_list ap;
  1911. -     va_start(ap, format);
  1912. -     _strbuf->vform(format, ap);
  1913. -     va_end(ap);
  1914. -     return *(ostream*)this;
  1915. - }
  1916. - istream& iostream::scan(const char *format ...) // Copy of istream::scan
  1917. - {
  1918. -     if (ipfx0()) {
  1919. -     va_list ap;
  1920. -     va_start(ap, format);
  1921. -     _strbuf->vscan(format, ap, &_state);
  1922. -     va_end(ap);
  1923. -     }
  1924. -     return *(istream *)this;
  1925. - }
  1926.   // NOTE: extension for compatibility with old libg++.
  1927.   // Not really compatible with fistream::close().
  1928.   #ifdef _STREAM_COMPAT
  1929. --- 733,738 ----
  1930. ***************
  1931. *** 705,717 ****
  1932.       delete _strbuf;
  1933.       else if (_strbuf->_flags & _S_IS_FILEBUF)
  1934.       ((struct filebuf*)_strbuf)->close();
  1935. !     else if (_strbuf != ¬_open_filebuf)
  1936.       _strbuf->sync();
  1937.       _flags |= ios::dont_close;
  1938. !     _strbuf = ¬_open_filebuf;
  1939.   }
  1940.   
  1941. ! int istream::skip(int i)
  1942.   {
  1943.       int old = (_flags & ios::skipws) != 0;
  1944.       if (i)
  1945. --- 742,755 ----
  1946.       delete _strbuf;
  1947.       else if (_strbuf->_flags & _S_IS_FILEBUF)
  1948.       ((struct filebuf*)_strbuf)->close();
  1949. !     else if (_strbuf != NULL)
  1950.       _strbuf->sync();
  1951.       _flags |= ios::dont_close;
  1952. !     _strbuf = NULL;
  1953. !     _state = badbit;
  1954.   }
  1955.   
  1956. ! int istream::skip(_G_size_t i)
  1957.   {
  1958.       int old = (_flags & ios::skipws) != 0;
  1959.       if (i)
  1960. *** 1.4    1992/06/03 02:12:17
  1961. --- makebuf.cc    1993/02/22 17:06:35
  1962. ***************
  1963. *** 27,33 ****
  1964.   #include <sys/stat.h>
  1965.   
  1966.   #ifdef atarist
  1967. ! extern "C" extern unsigned long __DEFAULT_BUFSIZ__;
  1968.   #undef BUFSIZ
  1969.   #define BUFSIZ __DEFAULT_BUFSIZ__
  1970.   #endif
  1971. --- 27,33 ----
  1972.   #include <sys/stat.h>
  1973.   
  1974.   #ifdef atarist
  1975. ! extern "C" unsigned long __DEFAULT_BUFSIZ__;
  1976.   #undef BUFSIZ
  1977.   #define BUFSIZ __DEFAULT_BUFSIZ__
  1978.   #endif
  1979. ***************
  1980. *** 65,71 ****
  1981.   #endif
  1982.       }
  1983.   #ifdef USE_MALLOC_BUF
  1984. !     if ((p = malloc(size)) == NULL) {
  1985.       unbuffered(1);
  1986.   //    fp->_bf._base = fp->_p = fp->_nbuf;
  1987.   //    fp->_bf._size = 1;
  1988. --- 65,71 ----
  1989.   #endif
  1990.       }
  1991.   #ifdef USE_MALLOC_BUF
  1992. !     if ((p = (char *)malloc(size)) == NULL) {
  1993.       unbuffered(1);
  1994.   //    fp->_bf._base = fp->_p = fp->_nbuf;
  1995.   //    fp->_bf._size = 1;
  1996. *** 1.10    1992/12/28 07:35:55
  1997. --- mincl    1993/02/22 17:06:36
  1998. ***************
  1999. *** 18,24 ****
  2000.   IOSRC = editbuf.cc filebuf.cc fstream.cc igetline.cc indstrea.cc iostream.cc \
  2001.   makebuf.cc parsestr.cc sbufvfor.cc sbufvsca.cc sgetline.cc stdstrbu.cc \
  2002.   stdstrea.cc stream.cc streambu.cc strstrea.cc xplotfil.cc xsfile.cc \
  2003. ! igetsb.cc iodtoa.cc outfloat.cc
  2004.   
  2005.   #
  2006.   # NOTE:: dummy[12].o MUST be the last objects on this list. otherwise you'll
  2007. --- 18,24 ----
  2008.   IOSRC = editbuf.cc filebuf.cc fstream.cc igetline.cc indstrea.cc iostream.cc \
  2009.   makebuf.cc parsestr.cc sbufvfor.cc sbufvsca.cc sgetline.cc stdstrbu.cc \
  2010.   stdstrea.cc stream.cc streambu.cc strstrea.cc xplotfil.cc xsfile.cc \
  2011. ! igetsb.cc iodtoa.cc outfloat.cc iomanip.cc stdiostr.cc
  2012.   
  2013.   #
  2014.   # NOTE:: dummy[12].o MUST be the last objects on this list. otherwise you'll
  2015. ***************
  2016. *** 64,70 ****
  2017.   _bin_del.o: gnuaux.c
  2018.       $(CC) -c $(CFLAGS) -DL_builtin_del $^ -o $@
  2019.   
  2020. ! # dont ask me why, but with gcc 2.3.1 and 2.3.2 -fomit-frame-pointer
  2021.   # breaks xbitset
  2022.   xbitset.o: xbitset.cc
  2023.       $(GXX) $(GXXFFLAGS) -c xbitset.cc
  2024. --- 64,70 ----
  2025.   _bin_del.o: gnuaux.c
  2026.       $(CC) -c $(CFLAGS) -DL_builtin_del $^ -o $@
  2027.   
  2028. ! # dont ask me why, but with gcc 2.3.1 and 2.3.2/3 -fomit-frame-pointer
  2029.   # breaks xbitset
  2030.   xbitset.o: xbitset.cc
  2031.       $(GXX) $(GXXFFLAGS) -c xbitset.cc
  2032. *** 1.2    1992/07/20 22:21:08
  2033. --- outfloat.cc    1993/02/22 17:06:36
  2034. ***************
  2035. *** 17,22 ****
  2036. --- 17,25 ----
  2037.   
  2038.   #include <ioprivat.h>
  2039.   
  2040. + // Format floating-point number and print them.
  2041. + // Return number of chars printed, or EOF on error.
  2042.   // sign_mode == '+' : print "-" or "+"
  2043.   // sign_mode == ' ' : print "-" or " "
  2044.   // sign_mode == '\0' : print "-' or ""
  2045. ***************
  2046. *** 25,37 ****
  2047.              int width, int precision, ios::fmtflags flags,
  2048.              char sign_mode, char fill)
  2049.   {
  2050. ! #define PUT(x) do {if (sb->sputc(x) < 0) goto error;} while (0)
  2051.   #define PUTN(p, n) \
  2052. !    do {int __n=n;if (sb->sputn(p, __n) != __n) goto error;} while (0)
  2053. ! #define PADN(fill, n) do {if (sb->padn(fill, n) < 0) goto error;} while (0)
  2054.       ios::fmtflags pad_kind = flags & (ios::left|ios::right|ios::internal);
  2055.       int skip_zeroes = 0;
  2056. !     int show_dot = flags & ios::showpoint;
  2057.       int decpt;
  2058.       int sign;
  2059.       int mode;
  2060. --- 28,42 ----
  2061.              int width, int precision, ios::fmtflags flags,
  2062.              char sign_mode, char fill)
  2063.   {
  2064. !     int count = 0;
  2065. ! #define PUT(x) do {if (sb->sputc(x) < 0) goto error; count++;} while (0)
  2066.   #define PUTN(p, n) \
  2067. !   do {_G_size_t _n=n; count+=_n; if (sb->sputn(p,_n) != _n) goto error;} while(0)
  2068. ! #define PADN(fill, n) \
  2069. !   do {_G_size_t _n = n; count+=_n; if (sb->padn(fill, _n) < 0) goto error;} while (0)
  2070.       ios::fmtflags pad_kind = flags & (ios::left|ios::right|ios::internal);
  2071.       int skip_zeroes = 0;
  2072. !     int show_dot = (flags & ios::showpoint) != 0;
  2073.       int decpt;
  2074.       int sign;
  2075.       int mode;
  2076. ***************
  2077. *** 47,61 ****
  2078. --- 52,69 ----
  2079.         case 'F':
  2080.       exp = 'e';
  2081.       mode = 0;
  2082. +     skip_zeroes = 1;
  2083.       type = 'g';
  2084.       break;
  2085.         case 'e':
  2086.       exp = 'e';
  2087.       mode = 2;
  2088. +     precision++;  // Add one to include digit before decimal point.
  2089.       break;
  2090.         case 'E':
  2091.       exp = 'E';
  2092.       mode = 2;
  2093. +     precision++;  // Add one to include digit before decimal point.
  2094.       break;
  2095.         case 'g':
  2096.         case 'G':
  2097. ***************
  2098. *** 75,81 ****
  2099.       // Check if we need to emit an exponent.
  2100.       if (mode != 3 && decpt != 9999) {
  2101.       i = decpt - 1;
  2102. !     if ((type != 'g' && type != 'F') || i <= -4 || i >= precision) {
  2103.           // Print the exponent into ebuf.
  2104.           // We write ebuf in reverse order (right-to-left).
  2105.           char sign;
  2106. --- 83,89 ----
  2107.       // Check if we need to emit an exponent.
  2108.       if (mode != 3 && decpt != 9999) {
  2109.       i = decpt - 1;
  2110. !     if ((type != 'g' && type != 'F') || i < -4 || i >= precision) {
  2111.           // Print the exponent into ebuf.
  2112.           // We write ebuf in reverse order (right-to-left).
  2113.           char sign;
  2114. ***************
  2115. *** 104,114 ****
  2116.       precision = 0;
  2117.       show_dot = 0;
  2118.       }
  2119. !     int trailing_zeroes = skip_zeroes ? 0 : precision-(useful_digits-decpt);
  2120.       if (trailing_zeroes < 0) trailing_zeroes = 0;
  2121.       if (trailing_zeroes != 0 || useful_digits > decpt)
  2122.       show_dot = 1;
  2123. -     int print_dot = 1;
  2124.       int print_sign;
  2125.       if (sign_mode == 0)
  2126.       print_sign = sign ? '-' : 0;
  2127. --- 112,135 ----
  2128.       precision = 0;
  2129.       show_dot = 0;
  2130.       }
  2131. !    // dtoa truncates trailing zeroes.  Set the variable trailing_zeroes to
  2132. !    // the number of 0's we have to add (after the decimal point).
  2133. !    int trailing_zeroes = 0;
  2134. !    if (skip_zeroes)
  2135. !        trailing_zeroes = 0;
  2136. !    else if (type == 'f')
  2137. !        trailing_zeroes = useful_digits <= decpt ? precision
  2138. !        : precision-(useful_digits-decpt);
  2139. !    else if (exponent_size) // 'e' 'E' or 'g' format using exponential notation.
  2140. !        trailing_zeroes = precision - useful_digits;
  2141. !    else // 'g' format not using exponential notation.
  2142. !        trailing_zeroes = useful_digits <= decpt ? precision - decpt
  2143. !        : precision-useful_digits;
  2144.       if (trailing_zeroes < 0) trailing_zeroes = 0;
  2145.       if (trailing_zeroes != 0 || useful_digits > decpt)
  2146.       show_dot = 1;
  2147.       int print_sign;
  2148.       if (sign_mode == 0)
  2149.       print_sign = sign ? '-' : 0;
  2150. ***************
  2151. *** 147,156 ****
  2152.       }
  2153.       else {
  2154.       PUT('0');
  2155. !     PUT('.');
  2156. !     PADN('0', -decpt);
  2157. !     // Print digits after the decimal point.
  2158. !     PUTN(p, useful_digits);
  2159.       }
  2160.       PADN('0', trailing_zeroes);
  2161.       if (exponent_size)
  2162. --- 168,179 ----
  2163.       }
  2164.       else {
  2165.       PUT('0');
  2166. !     if (show_dot) {
  2167. !         PUT('.');
  2168. !         PADN('0', -decpt);
  2169. !         // Print digits after the decimal point.
  2170. !         PUTN(p, useful_digits);
  2171. !     }
  2172.       }
  2173.       PADN('0', trailing_zeroes);
  2174.       if (exponent_size)
  2175. ***************
  2176. *** 157,163 ****
  2177.       PUTN(exponent_start, exponent_size);
  2178.       if (pad_kind == (ios::fmtflags)ios::left && padding > 0) // Left adjustment
  2179.       PADN(fill, padding);
  2180. !     return 0;
  2181.     error:
  2182.       return EOF;
  2183.   }
  2184. --- 180,186 ----
  2185.       PUTN(exponent_start, exponent_size);
  2186.       if (pad_kind == (ios::fmtflags)ios::left && padding > 0) // Left adjustment
  2187.       PADN(fill, padding);
  2188. !     return count;
  2189.     error:
  2190.       return EOF;
  2191.   }
  2192. *** 1.3    1992/07/20 22:21:08
  2193. --- parsestr.cc    1993/02/22 17:06:36
  2194. ***************
  2195. *** 21,32 ****
  2196.   #include <ioprivat.h>
  2197.   #include <parsestr.h>
  2198.   
  2199. ! streambuf* parsebuf::setbuf(char*, size_t)
  2200.   {
  2201.       return NULL;
  2202.   }
  2203.   
  2204. ! int parsebuf::tell_in_line()
  2205.   {
  2206.       return 0;
  2207.   }
  2208. --- 21,32 ----
  2209.   #include <ioprivat.h>
  2210.   #include <parsestr.h>
  2211.   
  2212. ! streambuf* parsebuf::setbuf(char*, _G_size_t)
  2213.   {
  2214.       return NULL;
  2215.   }
  2216.   
  2217. ! long parsebuf::tell_in_line()
  2218.   {
  2219.       return 0;
  2220.   }
  2221. ***************
  2222. *** 67,74 ****
  2223.   // The get area (eback() .. egptr()) is the extended current line
  2224.   // (i.e. with the '\n' at either end, if these exist).
  2225.   
  2226. ! string_parsebuf::string_parsebuf(char *buf, size_t len,
  2227. !                  int delete_at_close=0)
  2228.   : parsebuf()
  2229.   {
  2230.       setb(buf, buf+len, delete_at_close);
  2231. --- 67,74 ----
  2232.   // The get area (eback() .. egptr()) is the extended current line
  2233.   // (i.e. with the '\n' at either end, if these exist).
  2234.   
  2235. ! string_parsebuf::string_parsebuf(char *buf, _G_size_t len,
  2236. !                  int delete_at_close /* = 0*/)
  2237.   : parsebuf()
  2238.   {
  2239.       setb(buf, buf+len, delete_at_close);
  2240. ***************
  2241. *** 82,88 ****
  2242.   {
  2243.       register char* ptr = egptr(); // Point to end of current_line
  2244.       do {
  2245. !     long int i = right() - ptr;
  2246.       if (i <= 0)
  2247.           return EOF;
  2248.       ptr++; i--; // Skip '\n'.
  2249. --- 82,88 ----
  2250.   {
  2251.       register char* ptr = egptr(); // Point to end of current_line
  2252.       do {
  2253. !     long i = right() - ptr;
  2254.       if (i <= 0)
  2255.           return EOF;
  2256.       ptr++; i--; // Skip '\n'.
  2257. ***************
  2258. *** 104,120 ****
  2259.       return ptr;
  2260.   }
  2261.   
  2262. ! int string_parsebuf::tell_in_line()
  2263.   {
  2264. !     int offset = gptr() - eback();
  2265.       if (__line_number > 0)
  2266.       offset--;
  2267.       return offset;
  2268.   }
  2269.   
  2270. ! int string_parsebuf::seek_in_line(int i)
  2271.   {
  2272. !     int delta = i - tell_in_line();
  2273.       gbump(delta); // FIXME: Needs error (bounds) checking!
  2274.       return i;
  2275.   }
  2276. --- 104,120 ----
  2277.       return ptr;
  2278.   }
  2279.   
  2280. ! long string_parsebuf::tell_in_line()
  2281.   {
  2282. !     long offset = gptr() - eback();
  2283.       if (__line_number > 0)
  2284.       offset--;
  2285.       return offset;
  2286.   }
  2287.   
  2288. ! long string_parsebuf::seek_in_line(long i)
  2289.   {
  2290. !     long delta = i - tell_in_line();
  2291.       gbump(delta); // FIXME: Needs error (bounds) checking!
  2292.       return i;
  2293.   }
  2294. ***************
  2295. *** 126,132 ****
  2296.   {
  2297.       delete_buf = delete_arg_buf;
  2298.       sbuf = buf;
  2299. !     size_t buf_size = 128;
  2300.       char* buffer = ALLOC_BUF(buf_size);
  2301.       setb(buffer, buffer+buf_size, 1);
  2302.   //    setg(buffer, buffer, buffer);
  2303. --- 126,132 ----
  2304.   {
  2305.       delete_buf = delete_arg_buf;
  2306.       sbuf = buf;
  2307. !     _G_size_t buf_size = 128;
  2308.       char* buffer = ALLOC_BUF(buf_size);
  2309.       setb(buffer, buffer+buf_size, 1);
  2310.   //    setg(buffer, buffer, buffer);
  2311. ***************
  2312. *** 151,157 ****
  2313.       if (ch == EOF)
  2314.           break;
  2315.       if (ptr == ebuf()) {
  2316. !         size_t old_size = ebuf() - base();
  2317.           char *new_buffer = new char[old_size * 2];
  2318.           memcpy(new_buffer, base(), old_size);
  2319.           setb(new_buffer, new_buffer + 2 * old_size, 1);
  2320. --- 151,157 ----
  2321.       if (ch == EOF)
  2322.           break;
  2323.       if (ptr == ebuf()) {
  2324. !         _G_size_t old_size = ebuf() - base();
  2325.           char *new_buffer = new char[old_size * 2];
  2326.           memcpy(new_buffer, base(), old_size);
  2327.           setb(new_buffer, new_buffer + 2 * old_size, 1);
  2328. ***************
  2329. *** 178,192 ****
  2330.       return ret;
  2331.   }
  2332.   
  2333. ! int general_parsebuf::tell_in_line()
  2334.   {
  2335. !     size_t off = gptr() - base();
  2336.       if (__line_number > 1)
  2337.       off--; // Subtract 1 for '\n' from end of previous line.
  2338.       return off;
  2339.   }
  2340.   
  2341. ! int general_parsebuf::seek_in_line(int i)
  2342.   {
  2343.       if (__line_number == 0)
  2344.       (void)general_parsebuf::underflow();
  2345. --- 178,192 ----
  2346.       return ret;
  2347.   }
  2348.   
  2349. ! long general_parsebuf::tell_in_line()
  2350.   {
  2351. !     long off = gptr() - base();
  2352.       if (__line_number > 1)
  2353.       off--; // Subtract 1 for '\n' from end of previous line.
  2354.       return off;
  2355.   }
  2356.   
  2357. ! long general_parsebuf::seek_in_line(long i)
  2358.   {
  2359.       if (__line_number == 0)
  2360.       (void)general_parsebuf::underflow();
  2361. ***************
  2362. *** 193,199 ****
  2363.       if (__line_number > 1)
  2364.       i++; // Add 1 for '\n' from end of previous line.
  2365.       if (i < 0) i = 0;
  2366. !     size_t len = egptr() - eback();
  2367.       if (i > len) i = len;
  2368.       setg(base(), base() + i, egptr());
  2369.       return i;
  2370. --- 193,199 ----
  2371.       if (__line_number > 1)
  2372.       i++; // Add 1 for '\n' from end of previous line.
  2373.       if (i < 0) i = 0;
  2374. !     long len = egptr() - eback();
  2375.       if (i > len) i = len;
  2376.       setg(base(), base() + i, egptr());
  2377.       return i;
  2378. ***************
  2379. *** 210,216 ****
  2380.       backed_up_to_newline = 0;
  2381.   }
  2382.   
  2383. ! int func_parsebuf::tell_in_line()
  2384.   {
  2385.       if (buf_start == NULL)
  2386.       return 0;
  2387. --- 210,216 ----
  2388.       backed_up_to_newline = 0;
  2389.   }
  2390.   
  2391. ! long func_parsebuf::tell_in_line()
  2392.   {
  2393.       if (buf_start == NULL)
  2394.       return 0;
  2395. ***************
  2396. *** 228,234 ****
  2397.       return buf_start;
  2398.   }
  2399.   
  2400. ! int func_parsebuf::seek_in_line(int i)
  2401.   {
  2402.       if (i < 0) {
  2403.       // Back up to preceding '\n'.
  2404. --- 228,234 ----
  2405.       return buf_start;
  2406.   }
  2407.   
  2408. ! long func_parsebuf::seek_in_line(long i)
  2409.   {
  2410.       if (i < 0) {
  2411.       // Back up to preceding '\n'.
  2412. ***************
  2413. *** 238,244 ****
  2414.       return i;
  2415.       }
  2416.       backed_up_to_newline = 0;
  2417. !     int line_length = buf_end-buf_start;
  2418.       if (i <= line_length) {
  2419.       setg(buf_start, buf_start+i, buf_end);
  2420.       return i;
  2421. --- 238,244 ----
  2422.       return i;
  2423.       }
  2424.       backed_up_to_newline = 0;
  2425. !     long line_length = buf_end-buf_start;
  2426.       if (i <= line_length) {
  2427.       setg(buf_start, buf_start+i, buf_end);
  2428.       return i;
  2429. ***************
  2430. *** 288,294 ****
  2431.   }
  2432.   #endif
  2433.   
  2434. ! int parsebuf::seek_in_line(int i)
  2435.   {
  2436.   #if 1
  2437.       abort();
  2438. --- 288,294 ----
  2439.   }
  2440.   #endif
  2441.   
  2442. ! long parsebuf::seek_in_line(long i)
  2443.   {
  2444.   #if 1
  2445.       abort();
  2446. ***************
  2447. *** 296,302 ****
  2448.   #else
  2449.       if (i > 0) {
  2450.       size_t len = line_length();
  2451. !     if ((unsigned)i > len) i = len;
  2452.       }
  2453.       else if (i < -1) i = -1;
  2454.       int new_pos = seekoff(pos_at_line_start + i, ios::beg);
  2455. --- 296,302 ----
  2456.   #else
  2457.       if (i > 0) {
  2458.       size_t len = line_length();
  2459. !     if ((unsigned long)i > len) i = len;
  2460.       }
  2461.       else if (i < -1) i = -1;
  2462.       int new_pos = seekoff(pos_at_line_start + i, ios::beg);
  2463. *** 1.6    1992/07/20 22:21:08
  2464. --- sbufvfor.cc    1993/02/22 17:06:37
  2465. ***************
  2466. *** 50,58 ****
  2467.   class help_streambuf : public backupbuf {
  2468.     public:
  2469.       char *buffer;
  2470. !     size_t buf_size;
  2471.       streambuf *sb;
  2472. !     help_streambuf(streambuf *sbuf, char *buf, size_t n) {
  2473.       sb = sbuf; buffer = buf; buf_size = n;
  2474.       setp(buffer, buffer+buf_size); }
  2475.       ~help_streambuf();
  2476. --- 50,58 ----
  2477.   class help_streambuf : public backupbuf {
  2478.     public:
  2479.       char *buffer;
  2480. !     _G_size_t buf_size;
  2481.       streambuf *sb;
  2482. !     help_streambuf(streambuf *sbuf, char *buf, _G_size_t n) {
  2483.       sb = sbuf; buffer = buf; buf_size = n;
  2484.       setp(buffer, buffer+buf_size); }
  2485.       ~help_streambuf();
  2486. ***************
  2487. *** 136,148 ****
  2488.   #ifdef FLOATING_POINT
  2489.       int softsign;        /* temporary negative sign for floats */
  2490.       double _double;        /* double precision arguments %[eEfgG] */
  2491.       int fpprec;        /* `extra' floating precision in [eEfgG] */
  2492.   #endif
  2493.       unsigned long _ulong;    /* integer arguments %[diouxX] */
  2494.       enum { OCT, DEC, HEX } base;/* base for [diouxX] conversion */
  2495.       int dprec;        /* a copy of prec if [diouxX], 0 otherwise */
  2496. !     int fieldsz;        /* field size expanded by sign, etc */
  2497. !     int realsz;        /* field size expanded by dprec */
  2498.       // The initialization of 'size' is to suppress a warning that
  2499.       // 'size' might be used unitialized.  It seems gcc can't
  2500.       // quite grok this spaghetti code ...
  2501. --- 136,150 ----
  2502.   #ifdef FLOATING_POINT
  2503.       int softsign;        /* temporary negative sign for floats */
  2504.       double _double;        /* double precision arguments %[eEfgG] */
  2505. + #ifndef USE_DTOA
  2506.       int fpprec;        /* `extra' floating precision in [eEfgG] */
  2507.   #endif
  2508. + #endif
  2509.       unsigned long _ulong;    /* integer arguments %[diouxX] */
  2510.       enum { OCT, DEC, HEX } base;/* base for [diouxX] conversion */
  2511.       int dprec;        /* a copy of prec if [diouxX], 0 otherwise */
  2512. !     int dpad;        /* extra 0 padding needed for integers */
  2513. !     int fieldsz;        /* field size expanded by sign, dpad etc */
  2514.       // The initialization of 'size' is to suppress a warning that
  2515.       // 'size' might be used unitialized.  It seems gcc can't
  2516.       // quite grok this spaghetti code ...
  2517. ***************
  2518. *** 166,172 ****
  2519.        */
  2520.   #define    PRINT(ptr, len) \
  2521.     do { if (sputn(ptr, len) != len) goto error; } while (0)
  2522. - #define    FLUSH() { }
  2523.   #if 1
  2524.   #define PAD_SP(howmany) if (padn(' ', howmany) < 0) goto error;
  2525.   #define PAD_0(howmany) if (padn('0', howmany) < 0) goto error;
  2526. --- 168,173 ----
  2527. ***************
  2528. *** 220,226 ****
  2529.   
  2530.           flags = 0;
  2531.           dprec = 0;
  2532. ! #ifdef FLOATING_POINT
  2533.           fpprec = 0;
  2534.   #endif
  2535.           width = 0;
  2536. --- 221,227 ----
  2537.   
  2538.           flags = 0;
  2539.           dprec = 0;
  2540. ! #if defined(FLOATING_POINT) && !defined (USE_DTOA)
  2541.           fpprec = 0;
  2542.   #endif
  2543.           width = 0;
  2544. ***************
  2545. *** 254,259 ****
  2546. --- 255,261 ----
  2547.               /* FALLTHROUGH */
  2548.           case '-':
  2549.               flags |= LADJUST;
  2550. +             flags &= ~ZEROPAD; /* '-' disables '0' */
  2551.               goto rflag;
  2552.           case '+':
  2553.               sign = '+';
  2554. ***************
  2555. *** 277,283 ****
  2556.                * beginning of a field width.''
  2557.                *    -- ANSI X3J11
  2558.                */
  2559. !             flags |= ZEROPAD;
  2560.               goto rflag;
  2561.           case '1': case '2': case '3': case '4':
  2562.           case '5': case '6': case '7': case '8': case '9':
  2563. --- 279,286 ----
  2564.                * beginning of a field width.''
  2565.                *    -- ANSI X3J11
  2566.                */
  2567. !             if (!(flags & LADJUST))
  2568. !                 flags |= ZEROPAD; /* '-' disables '0' */
  2569.               goto rflag;
  2570.           case '1': case '2': case '3': case '4':
  2571.           case '5': case '6': case '7': case '8': case '9':
  2572. ***************
  2573. *** 327,342 ****
  2574.   #ifdef USE_DTOA
  2575.               {
  2576.                   ios::fmtflags fmt_flags = 0;
  2577.                   if (flags & ALT)
  2578.                   fmt_flags |= ios::showpoint;
  2579.                   if (flags & LADJUST)
  2580. !                 fmt_flags |= ios::right;
  2581. !                 if (__outfloat(_double, this, ch, width,
  2582.                          prec < 0 ? DEFPREC : prec,
  2583. !                        fmt_flags,
  2584. !                        sign,
  2585. !                        flags & ZEROPAD ? '0' : ' ') < 0)
  2586.                   goto error;
  2587.               }
  2588.               // CHECK ERROR!
  2589.               continue;
  2590. --- 330,348 ----
  2591.   #ifdef USE_DTOA
  2592.               {
  2593.                   ios::fmtflags fmt_flags = 0;
  2594. +                 int fill = ' ';
  2595.                   if (flags & ALT)
  2596.                   fmt_flags |= ios::showpoint;
  2597.                   if (flags & LADJUST)
  2598. !                 fmt_flags |= ios::left;
  2599. !                 else if (flags & ZEROPAD)
  2600. !                 fmt_flags |= ios::internal, fill = '0';
  2601. !                 n = __outfloat(_double, this, ch, width,
  2602.                          prec < 0 ? DEFPREC : prec,
  2603. !                        fmt_flags, sign, fill);
  2604. !                 if (n < 0)
  2605.                   goto error;
  2606. +                 ret += n;
  2607.               }
  2608.               // CHECK ERROR!
  2609.               continue;
  2610. ***************
  2611. *** 522,543 ****
  2612.   
  2613.           /*
  2614.            * compute actual size, so we know how much to pad.
  2615. -          * fieldsz excludes decimal prec; realsz includes it
  2616.            */
  2617. ! #ifdef FLOATING_POINT
  2618.           fieldsz = size + fpprec;
  2619.   #else
  2620.           fieldsz = size;
  2621.   #endif
  2622.           if (sign)
  2623.               fieldsz++;
  2624.           else if (flags & HEXPREFIX)
  2625.               fieldsz += 2;
  2626. !         realsz = dprec > fieldsz ? dprec : fieldsz;
  2627.   
  2628.           /* right-adjusting blank padding */
  2629.           if ((flags & (LADJUST|ZEROPAD)) == 0)
  2630. !             PAD_SP(width - realsz);
  2631.   
  2632.           /* prefix */
  2633.           if (sign) {
  2634. --- 528,552 ----
  2635.   
  2636.           /*
  2637.            * compute actual size, so we know how much to pad.
  2638.            */
  2639. ! #if defined(FLOATING_POINT) && !defined (USE_DTOA)
  2640.           fieldsz = size + fpprec;
  2641.   #else
  2642.           fieldsz = size;
  2643.   #endif
  2644. +         dpad = dprec - size;
  2645. +         if (dpad < 0)
  2646. +             dpad = 0;
  2647.           if (sign)
  2648.               fieldsz++;
  2649.           else if (flags & HEXPREFIX)
  2650.               fieldsz += 2;
  2651. !         fieldsz += dpad;
  2652.   
  2653.           /* right-adjusting blank padding */
  2654.           if ((flags & (LADJUST|ZEROPAD)) == 0)
  2655. !             PAD_SP(width - fieldsz);
  2656.   
  2657.           /* prefix */
  2658.           if (sign) {
  2659. ***************
  2660. *** 550,564 ****
  2661.   
  2662.           /* right-adjusting zero padding */
  2663.           if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD)
  2664. !             PAD_0(width - realsz);
  2665.   
  2666.           /* leading zeroes from decimal precision */
  2667. !         PAD_0(dprec - fieldsz);
  2668.   
  2669.           /* the string or number proper */
  2670.           PRINT(cp, size);
  2671.   
  2672. ! #ifdef FLOATING_POINT
  2673.           /* trailing f.p. zeroes */
  2674.           PAD_0(fpprec);
  2675.   #endif
  2676. --- 559,573 ----
  2677.   
  2678.           /* right-adjusting zero padding */
  2679.           if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD)
  2680. !             PAD_0(width - fieldsz);
  2681.   
  2682.           /* leading zeroes from decimal precision */
  2683. !         PAD_0(dpad);
  2684.   
  2685.           /* the string or number proper */
  2686.           PRINT(cp, size);
  2687.   
  2688. ! #if defined(FLOATING_POINT) && !defined (USE_DTOA)
  2689.           /* trailing f.p. zeroes */
  2690.           PAD_0(fpprec);
  2691.   #endif
  2692. ***************
  2693. *** 565,579 ****
  2694.   
  2695.           /* left-adjusting padding (always blank) */
  2696.           if (flags & LADJUST)
  2697. !             PAD_SP(width - realsz);
  2698.   
  2699.           /* finally, adjust ret */
  2700. !         ret += width > realsz ? width : realsz;
  2701.   
  2702. -         FLUSH();    /* copy out the I/O vectors */
  2703.       }
  2704.   done:
  2705. -     FLUSH();
  2706.       return ret;
  2707.   error:
  2708.       return EOF;
  2709. --- 574,586 ----
  2710.   
  2711.           /* left-adjusting padding (always blank) */
  2712.           if (flags & LADJUST)
  2713. !             PAD_SP(width - fieldsz);
  2714.   
  2715.           /* finally, adjust ret */
  2716. !         ret += width > fieldsz ? width : fieldsz;
  2717.   
  2718.       }
  2719.   done:
  2720.       return ret;
  2721.   error:
  2722.       return EOF;
  2723. ***************
  2724. *** 841,843 ****
  2725. --- 848,859 ----
  2726.   }
  2727.   
  2728.   #endif /* defined(FLOATING_POINT) && !defined(USE_DTOA) */
  2729. + int streambuf::form(char const *format ...)
  2730. + {
  2731. +     va_list ap;
  2732. +     va_start(ap, format);
  2733. +     int count = vform(format, ap);
  2734. +     va_end(ap);
  2735. +     return count;
  2736. + }
  2737. *** 1.5    1992/07/20 22:21:08
  2738. --- sbufvsca.cc    1993/02/22 17:06:37
  2739. ***************
  2740. *** 30,39 ****
  2741.   #include <varargs.h>
  2742.   #endif
  2743.   
  2744. - #ifdef sun /* SunOS incorrectly defines size_t to be int. */
  2745. - #define hardway
  2746. - #endif
  2747.   #ifndef    NO_FLOATING_POINT
  2748.   #define FLOATING_POINT
  2749.   #endif
  2750. --- 30,35 ----
  2751. ***************
  2752. *** 88,94 ****
  2753.   
  2754.   int streambuf::vscan(char const *fmt0,
  2755.                _G_va_list ap,
  2756. !              ios::iostate *state /* = NULL */)
  2757.   {
  2758.       register const u_char *fmt = (const u_char *)fmt0;
  2759.       register int c;        /* character from format, or conversion */
  2760. --- 84,90 ----
  2761.   
  2762.   int streambuf::vscan(char const *fmt0,
  2763.                _G_va_list ap,
  2764. !              ios *stream /* = NULL */)
  2765.   {
  2766.       register const u_char *fmt = (const u_char *)fmt0;
  2767.       register int c;        /* character from format, or conversion */
  2768. ***************
  2769. *** 417,431 ****
  2770.   
  2771.           case CT_INT:
  2772.               /* scan an integer as if by strtol/strtoul */
  2773. - #ifdef hardway
  2774.               if (width == 0 || width > sizeof(buf) - 1)
  2775.                   width = sizeof(buf) - 1;
  2776. - #else
  2777. -             /* size_t is unsigned, hence this optimisation */
  2778. -             if (--width > sizeof(buf) - 2)
  2779. -                 width = sizeof(buf) - 2;
  2780. -             width++;
  2781. - #endif
  2782.               flags |= SIGNOK | NDIGITS | NZDIGITS;
  2783.               for (p = buf; width; width--) {
  2784.                   c = *_gptr;
  2785. --- 413,420 ----
  2786. ***************
  2787. *** 555,569 ****
  2788.   #ifdef FLOATING_POINT
  2789.           case CT_FLOAT:
  2790.               /* scan a floating point number as if by strtod */
  2791. - #ifdef hardway
  2792.               if (width == 0 || width > sizeof(buf) - 1)
  2793.                   width = sizeof(buf) - 1;
  2794. - #else
  2795. -             /* size_t is unsigned, hence this optimisation */
  2796. -             if (--width > sizeof(buf) - 2)
  2797. -                 width = sizeof(buf) - 2;
  2798. -             width++;
  2799. - #endif
  2800.               flags |= SIGNOK | NDIGITS | DPTOK | EXPOK;
  2801.               for (p = buf; width; width--) {
  2802.                   c = *_gptr;
  2803. --- 544,551 ----
  2804. ***************
  2805. *** 655,665 ****
  2806.       if (nassigned == 0)
  2807.           nassigned = -1;
  2808.   match_failure:
  2809. !     if (state)
  2810. !         *state |= ios::failbit;
  2811.   done:
  2812. !     if (state && seen_eof)
  2813. !         *state |= ios::eofbit;
  2814.       return (nassigned);
  2815.   }
  2816.   
  2817. --- 637,647 ----
  2818.       if (nassigned == 0)
  2819.           nassigned = -1;
  2820.   match_failure:
  2821. !     if (stream)
  2822. !         stream->set(ios::failbit);
  2823.   done:
  2824. !     if (stream && seen_eof)
  2825. !         stream->set(ios::eofbit);
  2826.       return (nassigned);
  2827.   }
  2828.   
  2829. ***************
  2830. *** 756,759 ****
  2831. --- 738,750 ----
  2832.           }
  2833.       }
  2834.       /* NOTREACHED */
  2835. + }
  2836. + int streambuf::scan(char const *format ...)
  2837. + {
  2838. +     va_list ap;
  2839. +     va_start(ap, format);
  2840. +     int count = vscan(format, ap);
  2841. +     va_end(ap);
  2842. +     return count;
  2843.   }
  2844. *** 1.3    1992/06/08 20:42:41
  2845. --- sgetline.cc    1993/02/22 17:06:38
  2846. ***************
  2847. *** 21,27 ****
  2848.   
  2849.   // Read chars into buf (of size n), until delim is seen.
  2850.   // Return number of chars read (at most n-1).
  2851. ! // If extract_delim < 0, leave delimited unread.
  2852.   // If extract_delim > 0, insert delim in output.
  2853.   
  2854.   long streambuf::sgetline(char* buf, size_t n, char delim, int extract_delim)
  2855. --- 21,27 ----
  2856.   
  2857.   // Read chars into buf (of size n), until delim is seen.
  2858.   // Return number of chars read (at most n-1).
  2859. ! // If extract_delim < 0, leave delimiter unread.
  2860.   // If extract_delim > 0, insert delim in output.
  2861.   
  2862.   long streambuf::sgetline(char* buf, size_t n, char delim, int extract_delim)
  2863. *** 1.4    1992/06/03 02:12:17
  2864. --- stdstrbu.cc    1993/02/22 17:06:38
  2865. ***************
  2866. *** 16,28 ****
  2867.   //    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  2868.   
  2869.   #include <ioprivat.h>
  2870. ! #include <g_config.h>
  2871.   
  2872. ! #if _G_NAMES_HAVE_UNDERSCORE
  2873. ! #define UNDERSCORE "_"
  2874. ! #else
  2875. ! #define UNDERSCORE ""
  2876. ! #endif
  2877.   
  2878.   // To avoid problems depending on constructor order (and for
  2879.   // efficiency) the standard streambufs (and streams) are
  2880. --- 16,32 ----
  2881.   //    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  2882.   
  2883.   #include <ioprivat.h>
  2884. ! #include <stdio.h>
  2885.   
  2886. ! // This file defines the standard streambufs, corresponding to cin, cout, cerr.
  2887. ! // We define two sets:
  2888. ! //
  2889. ! // __std_filebuf_0, __std_filebuf_1, __std_filebuf_2 are filebufs using
  2890. ! // file descriptor 0/1/2.
  2891. ! //
  2892. ! // __stdin_stdiobuf, __stdout_stdiobuf, __stderr_stdiobuf are stdiostreams
  2893. ! // pointing to stdin, stdout, stderr.
  2894.   
  2895.   // To avoid problems depending on constructor order (and for
  2896.   // efficiency) the standard streambufs (and streams) are
  2897. ***************
  2898. *** 35,40 ****
  2899. --- 39,52 ----
  2900.   // (the address of) the virtual function table for the
  2901.   // filebuf class.
  2902.   
  2903. + #if _G_NAMES_HAVE_UNDERSCORE
  2904. + #define UNDERSCORE "_"
  2905. + #else
  2906. + #define UNDERSCORE ""
  2907. + #endif
  2908. + // First define the filebuf-based objects.
  2909.   #if !defined(vt_filebuf)
  2910.   #ifndef __GNUG__
  2911.   // This works for cfront.
  2912. ***************
  2913. *** 53,68 ****
  2914.       struct __file_fields f;
  2915.   };
  2916.   
  2917. ! #define DEF_STD(NAME, FD, CHAIN, FLAGS) \
  2918. !     _fake_filebuf NAME[1] = {{\
  2919.          { _IO_MAGIC+_S_LINKED+_S_IS_FILEBUF+_S_IS_BACKUPBUF+FLAGS, \
  2920. !      0, 0, 0, 0, 0, 0, 0, 0, CHAIN, 0, 0, 0, 0, 0},\
  2921. !        vt_filebuf, {FD}}};
  2922.   
  2923. ! DEF_STD(_cin_sbuf, 0, 0, _S_NO_WRITES);
  2924. ! DEF_STD(_cout_sbuf, 1, (streambuf*)_cin_sbuf, _S_NO_READS);
  2925. ! DEF_STD(_cerr_sbuf, 2, (streambuf*)_cout_sbuf, _S_NO_READS);
  2926.   
  2927. ! DEF_STD(not_open_filebuf, -1, (streambuf*)0, _S_NO_READS+_S_NO_WRITES);
  2928.   
  2929. ! streambuf* streambuf::_list_all = (streambuf*)_cerr_sbuf;
  2930. --- 65,112 ----
  2931.       struct __file_fields f;
  2932.   };
  2933.   
  2934. ! #define FILEBUF_LITERAL(CHAIN, FLAGS) \
  2935.          { _IO_MAGIC+_S_LINKED+_S_IS_FILEBUF+_S_IS_BACKUPBUF+FLAGS, \
  2936. !      0, 0, 0, 0, 0, 0, 0, 0, CHAIN, 0, 0, 0, 0, 0}
  2937.   
  2938. ! #define DEF_FILEBUF(NAME, FD, CHAIN, FLAGS) \
  2939. !   _fake_filebuf NAME[1] = {{FILEBUF_LITERAL(CHAIN, FLAGS), vt_filebuf, {FD}}};
  2940.   
  2941. ! DEF_FILEBUF(__std_filebuf_0, 0, 0, _S_NO_WRITES);
  2942. ! DEF_FILEBUF(__std_filebuf_1, 1, (streambuf*)__std_filebuf_0, _S_NO_READS);
  2943. ! DEF_FILEBUF(__std_filebuf_2, 2, (streambuf*)__std_filebuf_1,
  2944. !         _S_NO_READS+_S_UNBUFFERED);
  2945. ! // Nest define the stdiobuf-bases objects.
  2946. ! #if !defined(vt_stdiobuf)
  2947. ! #ifndef __GNUG__
  2948. ! // This works for cfront.
  2949. ! #define vt_stdiobuf __vtbl__7stdiobuf
  2950. ! extern char vt_stdiobuf[1];
  2951. ! #elif _G_DOLLAR_IN_LABEL
  2952. ! extern char vt_stdiobuf[1] asm(UNDERSCORE "_vt$stdiobuf");
  2953. ! #else
  2954. ! extern char vt_stdiobuf[1] asm(UNDERSCORE "_vt.stdiobuf");
  2955. ! #endif
  2956. ! #endif /* !defined(vt_stdiobuf) */
  2957. ! struct _fake_stdiobuf {
  2958. !     struct __streambuf s;
  2959. !     char* vtable;
  2960. !     struct __file_fields f;
  2961. !     FILE *_f;
  2962. ! };
  2963.   
  2964. ! #define DEF_STDIOBUF(NAME, FILE, FD, CHAIN, FLAGS) \
  2965. !     _fake_stdiobuf NAME[1] = {{ \
  2966. !      FILEBUF_LITERAL(CHAIN, (FLAGS)|_S_UNBUFFERED),\
  2967. !      vt_stdiobuf, {FD}, FILE}};
  2968. ! DEF_STDIOBUF(__stdin_stdiobuf, stdin, 0, (streambuf*)__std_filebuf_2,
  2969. !          _S_NO_WRITES);
  2970. ! DEF_STDIOBUF(__stdout_stdiobuf, stdout, 1, (streambuf*)__stdin_stdiobuf,
  2971. !          _S_NO_READS);
  2972. ! DEF_STDIOBUF(__stderr_stdiobuf, stderr, 2, (streambuf*)__stdout_stdiobuf,
  2973. !          _S_NO_READS);
  2974. ! streambuf* streambuf::_list_all = (streambuf*)__stderr_stdiobuf;
  2975. *** 1.4    1992/06/03 02:12:17
  2976. --- stdstrea.cc    1993/02/22 17:06:38
  2977. ***************
  2978. *** 18,40 ****
  2979.   #include <ioprivat.h>
  2980.   #include <g_config.h>
  2981.   
  2982. ! #if _G_NAMES_HAVE_UNDERSCORE
  2983.   #define UNDERSCORE "_"
  2984.   #else
  2985.   #define UNDERSCORE ""
  2986.   #endif
  2987.   
  2988. ! struct _fake_filebuf;
  2989. ! extern _fake_filebuf _cin_sbuf, _cout_sbuf, _cerr_sbuf;
  2990. ! #if 0 /* defined(__GNUC__) */
  2991. ! // This hack was intended to trick gdb into thinking cin is really a
  2992. ! // istream (and not a _fake_istream), but doesn't seem to work.
  2993. ! #define STR_NAME(TYPE, NAME) TYPE __##NAME asm(UNDERSCORE #NAME)
  2994.   #else
  2995. ! #define STR_NAME(TYPE, NAME) TYPE NAME
  2996.   #endif
  2997.   #define cin CIN
  2998.   #define cout COUT
  2999.   #define cerr CERR
  3000. --- 18,58 ----
  3001.   #include <ioprivat.h>
  3002.   #include <g_config.h>
  3003.   
  3004. ! // The ANSI draft requires that operations on cin/cout/cerr can be
  3005. ! // mixed with operations on stdin/stdout/stderr on a character by
  3006. ! // character basis.  This normally requires that the streambuf's
  3007. ! // used by cin/cout/cerr be stdiostreams.  However, if the stdio
  3008. ! // implementation is the one that is built using this library,
  3009. ! // then we don't need to, since in that case stdin/stdout/stderr
  3010. ! // are identical to &__std_filebuf_0/&__std_filebuf_1/&__std_filebuf_2.
  3011. ! #ifdef _STDIO_USES_IOSTREAM
  3012. ! #define USE_FILEBUF
  3013. ! #endif
  3014. ! #if defined(NAMES_HAVE_UNDERSCORE) || defined(_G_NAMES_HAVE_UNDERSCORE)
  3015.   #define UNDERSCORE "_"
  3016.   #else
  3017.   #define UNDERSCORE ""
  3018.   #endif
  3019.   
  3020. ! #ifdef USE_FILEBUF
  3021. ! #define CIN_SBUF __std_filebuf_0
  3022. ! #define COUT_SBUF __std_filebuf_1
  3023. ! #define CERR_SBUF __std_filebuf_2
  3024. ! static int use_stdiobuf = 0;
  3025.   #else
  3026. ! #define CIN_SBUF __stdin_stdiobuf
  3027. ! #define COUT_SBUF __stdout_stdiobuf
  3028. ! #define CERR_SBUF __stderr_stdiobuf
  3029. ! static int use_stdiobuf = 1;
  3030.   #endif
  3031. + struct _fake_filebuf;
  3032. + extern _fake_filebuf __std_filebuf_0, __std_filebuf_1, __std_filebuf_2;
  3033. + struct _fake_stdiobuf;
  3034. + extern _fake_stdiobuf __stdin_stdiobuf, __stdout_stdiobuf, __stderr_stdiobuf;
  3035.   #define cin CIN
  3036.   #define cout COUT
  3037.   #define cerr CERR
  3038. ***************
  3039. *** 50,71 ****
  3040.   #else
  3041.   #define PAD 1
  3042.   #endif
  3043. ! class _fake_istream {
  3044.       _ios_fields base;
  3045.       char filler[sizeof(struct istream)-sizeof(struct _ios_fields)+PAD];
  3046.   };
  3047. ! class _fake_ostream {
  3048.       _ios_fields base;
  3049.       char filler[sizeof(struct ostream)-sizeof(struct _ios_fields)+PAD];
  3050.   };
  3051.   
  3052.   #define STD_STR(SBUF, TIE, EXTRA_FLAGS) \
  3053. !  (streambuf*)&SBUF, TIE, 0, ios::dont_close|ios::skipws|EXTRA_FLAGS, ' ', 0, 6
  3054.   
  3055. ! STR_NAME(_fake_ostream, cout)  = { STD_STR(_cout_sbuf, NULL, 0) };
  3056. ! STR_NAME(_fake_ostream, cerr) =
  3057. !   { STD_STR(_cerr_sbuf, (ostream*)&cout, ios::unitbuf) };
  3058. ! STR_NAME(_fake_istream, cin)  = { STD_STR(_cin_sbuf,  (ostream*)&cout, 0) };
  3059.   
  3060.   /* Only for (partial) compatibility with AT&T's library. */
  3061. ! STR_NAME(_fake_ostream, clog) = { STD_STR(_cerr_sbuf, (ostream*)&cout, 0) };
  3062. --- 68,127 ----
  3063.   #else
  3064.   #define PAD 1
  3065.   #endif
  3066. ! struct _fake_istream {
  3067. !     struct myfields {
  3068. !     _ios_fields *vb; /* pointer to virtual base class ios */
  3069. !     _G_ssize_t _gcount;
  3070. !     } mine;
  3071.       _ios_fields base;
  3072.       char filler[sizeof(struct istream)-sizeof(struct _ios_fields)+PAD];
  3073.   };
  3074. ! struct _fake_ostream {
  3075. !     struct myfields {
  3076. !     _ios_fields *vb; /* pointer to virtual base class ios */
  3077. !     } mine;
  3078.       _ios_fields base;
  3079.       char filler[sizeof(struct ostream)-sizeof(struct _ios_fields)+PAD];
  3080.   };
  3081.   
  3082.   #define STD_STR(SBUF, TIE, EXTRA_FLAGS) \
  3083. !  (streambuf*)&SBUF, TIE, 0, ios::dont_close|ios::skipws|EXTRA_FLAGS, ' ',0,0,6
  3084. ! #define STREAM_DEF(TYPE, NAME, SBUF, TIE, EXTRA_FLAGS) \
  3085. !   TYPE NAME = { {&NAME.base}, {STD_STR(SBUF, TIE, EXTRA_FLAGS) }};
  3086.   
  3087. ! STREAM_DEF(_fake_ostream, cout, COUT_SBUF, NULL, 0)
  3088. ! STREAM_DEF(_fake_ostream, cerr, CERR_SBUF, (ostream*)&cout, ios::unitbuf)
  3089. ! STREAM_DEF(_fake_istream, cin, CIN_SBUF,  (ostream*)&cout, 0)
  3090.   
  3091.   /* Only for (partial) compatibility with AT&T's library. */
  3092. ! STREAM_DEF(_fake_ostream, clog, CERR_SBUF, (ostream*)&cout, 0)
  3093. ! // Switches between using __std_filebuf_{0,1,2} and
  3094. ! // __std{in,out,err}_stdiobuf for standard streams.  This is
  3095. ! // normally not needed, but is provided for AT&T compatibility.
  3096. ! int ios::sync_with_stdio(int new_state)
  3097. ! {
  3098. ! #ifdef _STDIO_USES_IOSTREAM
  3099. !     // It is always synced.
  3100. !     return 0;
  3101. ! #else
  3102. !     if (new_state == use_stdiobuf) // The usual case now.
  3103. !     return use_stdiobuf;
  3104. !     if (new_state) {
  3105. !     cout.base._strbuf = (streambuf*)&__stdout_stdiobuf;
  3106. !     cin.base._strbuf = (streambuf*)&__stdin_stdiobuf;
  3107. !     cerr.base._strbuf = (streambuf*)&__stderr_stdiobuf;
  3108. !     clog.base._strbuf = (streambuf*)&__stderr_stdiobuf;
  3109. !     } else {
  3110. !     cout.base._strbuf = (streambuf*)&__std_filebuf_1;
  3111. !     cin.base._strbuf = (streambuf*)&__std_filebuf_0;
  3112. !     cerr.base._strbuf = (streambuf*)&__std_filebuf_2;
  3113. !     clog.base._strbuf = (streambuf*)&__std_filebuf_2;
  3114. !     }
  3115. !     int old_state = use_stdiobuf;
  3116. !     use_stdiobuf = new_state;
  3117. !     return old_state;
  3118. ! #endif
  3119. ! }
  3120. *** 1.5    1992/06/03 02:12:17
  3121. --- stream.cc    1993/02/22 17:06:39
  3122. ***************
  3123. *** 17,23 ****
  3124.   
  3125.   char* form(const char* format, ...)
  3126.   {
  3127. !     size_t space_left = EndBuffer - next_chunk;
  3128.       // If less that 25% of the space is available start over.
  3129.       if (space_left < (BUFSIZ>>2))
  3130.       next_chunk = Buffer;
  3131. --- 17,23 ----
  3132.   
  3133.   char* form(const char* format, ...)
  3134.   {
  3135. !     _G_size_t space_left = EndBuffer - next_chunk;
  3136.       // If less that 25% of the space is available start over.
  3137.       if (space_left < (BUFSIZ>>2))
  3138.       next_chunk = Buffer;
  3139. ***************
  3140. *** 41,47 ****
  3141.       // for each input byte, but normally 3 is plenty.
  3142.       int needed = size ? size
  3143.       : (base >= 8 ? 3 : 8) * sizeof(unsigned long) + 2;
  3144. !     size_t space_left = EndBuffer - next_chunk;
  3145.       if (space_left <= needed)
  3146.       next_chunk = Buffer; // start over.
  3147.   
  3148. --- 41,47 ----
  3149.       // for each input byte, but normally 3 is plenty.
  3150.       int needed = size ? size
  3151.       : (base >= 8 ? 3 : 8) * sizeof(unsigned long) + 2;
  3152. !     _G_size_t space_left = EndBuffer - next_chunk;
  3153.       if (space_left <= needed)
  3154.       next_chunk = Buffer; // start over.
  3155.   
  3156. *** 1.6    1992/07/20 22:21:08
  3157. --- streambu.cc    1993/02/22 17:06:39
  3158. ***************
  3159. *** 22,27 ****
  3160. --- 22,50 ----
  3161.   #include <ioprivat.h>
  3162.   #include <string.h>
  3163.   
  3164. + void streambuf::_un_link()
  3165. + {
  3166. +     if (_flags & _S_LINKED) {
  3167. +     streambuf **f;
  3168. +     for (f = &_list_all; *f != NULL; f = &(*f)->xchain()) {
  3169. +         if (*f == this) {
  3170. +         *f = xchain();
  3171. +         break;
  3172. +         }
  3173. +     }
  3174. +     _flags &= ~_S_LINKED;
  3175. +     }
  3176. + }
  3177. + void streambuf::_link_in()
  3178. + {
  3179. +     if ((_flags & _S_LINKED) == 0) {
  3180. +     _flags |= _S_LINKED;
  3181. +     xchain() = _list_all;
  3182. +     _list_all = this;
  3183. +     }
  3184. + }
  3185.   // Return minimum _pos markers
  3186.   // Assumes the current get area is the main get area.
  3187.   long streambuf::_least_marker()
  3188. ***************
  3189. *** 190,196 ****
  3190.   // for the atari we take a hit here so that bin/text modes are taken care of
  3191.   // automatically by sputc/sbumpc
  3192.   
  3193. ! size_t streambuf::sputn(const char* s, size_t n) // OPTIMIZE THIS!
  3194.   {
  3195.       size_t count = 0;
  3196.   
  3197. --- 213,219 ----
  3198.   // for the atari we take a hit here so that bin/text modes are taken care of
  3199.   // automatically by sputc/sbumpc
  3200.   
  3201. ! _G_size_t streambuf::xsputn(const char* s, _G_size_t n) // OPTIMIZE THIS!
  3202.   {
  3203.       size_t count = 0;
  3204.   
  3205. ***************
  3206. *** 203,209 ****
  3207.       return count;
  3208.   }
  3209.   
  3210. ! size_t streambuf::sgetn(char* s, size_t n) // OPTIMIZE THIS!
  3211.   {
  3212.       size_t count = 0;
  3213.       for (; count < n; count++) {
  3214. --- 226,232 ----
  3215.       return count;
  3216.   }
  3217.   
  3218. ! _G_size_t streambuf::xsgetn(char* s, _G_size_t n) // OPTIMIZE THIS!
  3219.   {
  3220.       size_t count = 0;
  3221.       for (; count < n; count++) {
  3222. ***************
  3223. *** 215,221 ****
  3224.       return count;
  3225.   }
  3226.   
  3227. ! size_t streambuf::ignore(size_t n)
  3228.   {
  3229.       size_t more = n;
  3230.       int ch;
  3231. --- 238,244 ----
  3232.       return count;
  3233.   }
  3234.   
  3235. ! _G_size_t streambuf::ignore(_G_size_t n)
  3236.   {
  3237.       size_t more = n;
  3238.       int ch;
  3239. ***************
  3240. *** 225,237 ****
  3241.   }
  3242.   
  3243.   #else
  3244. ! size_t streambuf::sputn(register const char* s, size_t n)
  3245.   {
  3246. !     if (n <= 0)
  3247.       return 0;
  3248. !     register size_t more = n;
  3249.       for (;;) {
  3250. !     size_t count = _epptr - _pptr; // Space available.
  3251.       if (count > 0) {
  3252.           if (count > more)
  3253.           count = more;
  3254. --- 248,261 ----
  3255.   }
  3256.   
  3257.   #else
  3258. ! _G_size_t streambuf::xsputn(register const char* s, _G_size_t n)
  3259.   {
  3260. !     if ((long)n <= 0)
  3261.       return 0;
  3262. !     register _G_size_t more = n;
  3263.       for (;;) {
  3264. !     long count = _epptr - _pptr; // Space available.
  3265.       if (count > 0) {
  3266.           if (count > more)
  3267.           count = more;
  3268. ***************
  3269. *** 257,267 ****
  3270.   }
  3271.   
  3272.   
  3273. ! size_t streambuf::sgetn(char* s, size_t n)
  3274.   {
  3275. !     register size_t more = n;
  3276.       for (;;) {
  3277. !     size_t count = _egptr - _gptr; // Data available.
  3278.       if (count > 0) {
  3279.           if (count > more)
  3280.           count = more;
  3281. --- 281,291 ----
  3282.   }
  3283.   
  3284.   
  3285. ! _G_size_t streambuf::xsgetn(char* s, _G_size_t n)
  3286.   {
  3287. !     register _G_size_t more = n;
  3288.       for (;;) {
  3289. !     long count = _egptr - _gptr; // Data available.
  3290.       if (count > 0) {
  3291.           if (count > more)
  3292.           count = more;
  3293. ***************
  3294. *** 285,295 ****
  3295.       return n - more;
  3296.   }
  3297.   
  3298. ! size_t streambuf::ignore(size_t n)
  3299.   {
  3300. !     register size_t more = n;
  3301.       for (;;) {
  3302. !     long count = _egptr - _gptr; // Data available.
  3303.       if (count > 0) {
  3304.           if (count > more)
  3305.           count = more;
  3306. --- 309,319 ----
  3307.       return n - more;
  3308.   }
  3309.   
  3310. ! _G_size_t streambuf::ignore(_G_size_t n)
  3311.   {
  3312. !     register _G_size_t more = n;
  3313.       for (;;) {
  3314. !     int long = _egptr - _gptr; // Data available.
  3315.       if (count > 0) {
  3316.           if (count > more)
  3317.           count = more;
  3318. ***************
  3319. *** 301,309 ****
  3320.       }
  3321.       return n - more;
  3322.   }
  3323. ! #endif /* atari */
  3324.   
  3325. ! int streambuf::padn(char pad, int count)
  3326.   {
  3327.   #define PADSIZE 16
  3328.       static char const blanks[PADSIZE] =
  3329. --- 325,333 ----
  3330.       }
  3331.       return n - more;
  3332.   }
  3333. ! #endif
  3334.   
  3335. ! int streambuf::padn(char pad, _G_size_t count)
  3336.   {
  3337.   #define PADSIZE 16
  3338.       static char const blanks[PADSIZE] =
  3339. ***************
  3340. *** 312,318 ****
  3341.        {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'};
  3342.       char padbuf[PADSIZE];
  3343.       const char *padptr;
  3344. !     register int i;
  3345.       
  3346.       if (pad == ' ')
  3347.       padptr = blanks;
  3348. --- 336,342 ----
  3349.        {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'};
  3350.       char padbuf[PADSIZE];
  3351.       const char *padptr;
  3352. !     register long i;
  3353.       
  3354.       if (pad == ' ')
  3355.       padptr = blanks;
  3356. ***************
  3357. *** 339,355 ****
  3358.   
  3359.   int streambuf::pbackfail(int c)
  3360.   {
  3361. !     return EOF;
  3362. ! }
  3363. ! int streambuf::ungetfail()
  3364. ! {
  3365. !     if (seekoff(-1, ios::cur, ios::in) == EOF)
  3366.       return EOF;
  3367. !     return sgetc();
  3368.   }
  3369.   
  3370. ! streambuf* streambuf::setbuf(char* p, size_t len)
  3371.   {
  3372.       if (sync() == EOF)
  3373.       return NULL;
  3374. --- 363,378 ----
  3375.   
  3376.   int streambuf::pbackfail(int c)
  3377.   {
  3378. !     if (_gptr > _eback)
  3379. !     _gptr--;
  3380. !     else if (seekoff(-1, ios::cur, ios::in) == EOF)
  3381.       return EOF;
  3382. !     if (c != EOF && *_gptr != c)
  3383. !     *_gptr = c;
  3384. !     return (unsigned char)c;
  3385.   }
  3386.   
  3387. ! streambuf* streambuf::setbuf(char* p, _G_size_t len)
  3388.   {
  3389.       if (sync() == EOF)
  3390.       return NULL;
  3391. ***************
  3392. *** 388,394 ****
  3393.   
  3394.   int streambuf::doallocate()
  3395.   {
  3396. !     char *buf = malloc((size_t)__DEFAULT_BUFSIZ__);
  3397.       if (buf == NULL)
  3398.       return EOF;
  3399.       setb(buf, buf+__DEFAULT_BUFSIZ__, 1);
  3400. --- 411,417 ----
  3401.   
  3402.   int streambuf::doallocate()
  3403.   {
  3404. !     char *buf = (char *)malloc((size_t)__DEFAULT_BUFSIZ__);
  3405.       if (buf == NULL)
  3406.       return EOF;
  3407.       setb(buf, buf+__DEFAULT_BUFSIZ__, 1);
  3408. ***************
  3409. *** 412,421 ****
  3410.   }
  3411.   
  3412.   #ifdef atarist
  3413. ! extern "C" extern int __default_mode__;
  3414.   #endif
  3415.   
  3416. ! streambuf::streambuf(long flags)
  3417.   {
  3418.   #ifdef atarist
  3419.     if(!(flags & _IOS_TEXT))
  3420. --- 435,444 ----
  3421.   }
  3422.   
  3423.   #ifdef atarist
  3424. ! extern "C" int __default_mode__;
  3425.   #endif
  3426.   
  3427. ! streambuf::streambuf(unsigned long flags)
  3428.   {
  3429.   #ifdef atarist
  3430.     if(!(flags & _IOS_TEXT))
  3431. ***************
  3432. *** 461,482 ****
  3433.   
  3434.   int streambuf::sputbackc(char c)
  3435.   {
  3436. !     if (gptr() <= eback()) return pbackfail(c);
  3437. !     gbump(-1);
  3438. !     // Don't write into the get buffer if we don't have to.
  3439. !     if (*gptr() != c)
  3440. !     *gptr() = c;
  3441. !     return (unsigned char)c;
  3442.   }
  3443.   
  3444.   int streambuf::sungetc()
  3445.   {
  3446. !     if (gptr() > eback()) {
  3447. !     gbump(-1);
  3448. !     return (unsigned char)*gptr();
  3449.       }
  3450.       else
  3451. !     return ungetfail();
  3452.   }
  3453.   
  3454.   #if 0 /* Work in progress */
  3455. --- 484,504 ----
  3456.   
  3457.   int streambuf::sputbackc(char c)
  3458.   {
  3459. !     if (_gptr > _eback && (unsigned char)_gptr[-1] == (unsigned char)c) {
  3460. !     _gptr--;
  3461. !     return (unsigned char)c;
  3462. !     }
  3463. !     return pbackfail(c);
  3464.   }
  3465.   
  3466.   int streambuf::sungetc()
  3467.   {
  3468. !     if (_gptr > _eback) {
  3469. !     _gptr--;
  3470. !     return (unsigned char)*_gptr;
  3471.       }
  3472.       else
  3473. !     return pbackfail(EOF);
  3474.   }
  3475.   
  3476.   #if 0 /* Work in progress */
  3477. ***************
  3478. *** 499,505 ****
  3479.   
  3480.   int streambuf::set_column(int i)
  3481.   {
  3482. -     overflow(EOF);
  3483.       _cur_column = i+1;
  3484.       return 0;
  3485.   }
  3486. --- 521,526 ----
  3487. ***************
  3488. *** 606,612 ****
  3489.       }
  3490.   }
  3491.   
  3492. ! int streambuf::seekmark(streammarker& mark, int delta = 0)
  3493.   {
  3494.       if (mark._sbuf != this)
  3495.       return EOF;
  3496. --- 627,633 ----
  3497.       }
  3498.   }
  3499.   
  3500. ! int streambuf::seekmark(streammarker& mark, long delta /* = 0 */)
  3501.   {
  3502.       if (mark._sbuf != this)
  3503.       return EOF;
  3504. ***************
  3505. *** 673,682 ****
  3506.       setg(new_buf, new_buf+(new_size-old_size), new_buf+new_size);
  3507.       _aux_limit = _gptr;
  3508.       }
  3509. !     gbump(-1);
  3510. !     if (*gptr() != c)
  3511. !     *gptr() = c;
  3512. !     return (unsigned char)c;
  3513.   }
  3514.   
  3515.   unsigned __adjust_column(unsigned start, const char *line, int count)
  3516. --- 694,703 ----
  3517.       setg(new_buf, new_buf+(new_size-old_size), new_buf+new_size);
  3518.       _aux_limit = _gptr;
  3519.       }
  3520. !     _gptr--;
  3521. !     if (c != EOF && *_gptr != c)
  3522. !     *_gptr = c;
  3523. !     return (unsigned char)*_gptr;
  3524.   }
  3525.   
  3526.   unsigned __adjust_column(unsigned start, const char *line, int count)
  3527. ***************
  3528. *** 688,693 ****
  3529. --- 709,719 ----
  3530.       return start + count;
  3531.   }
  3532.   
  3533. + int ios::readable() { return !(rdbuf()->_flags & _S_NO_READS); }
  3534. + int ios::writable() { return !(rdbuf()->_flags & _S_NO_WRITES); }
  3535. + int ios::is_open() { return rdbuf()
  3536. +              && (rdbuf()->_flags & _S_NO_READS+_S_NO_WRITES)
  3537. +                  != _S_NO_READS+_S_NO_WRITES; }
  3538.   
  3539.   #if defined(linux)
  3540.   #define IO_CLEANUP ;
  3541. *** 1.6    1992/07/17 18:24:43
  3542. --- strstrea.cc    1993/02/22 17:06:39
  3543. ***************
  3544. *** 21,58 ****
  3545.   #include <ioprivat.h>
  3546.   #include <strstrea.h>
  3547.   
  3548. ! istrstream::istrstream(char *cp) : istream(NULL)
  3549.   {
  3550. !     _strbuf = new strstreambuf(cp, 0, NULL);
  3551.   }
  3552.   
  3553. ! istrstream::istrstream(char *cp, int n) : istream(NULL)
  3554.   {
  3555. !     _strbuf = new strstreambuf(cp, n, NULL);
  3556.   }
  3557.   
  3558. ! ostrstream::ostrstream() : ostream(NULL)
  3559.   {
  3560. !     _strbuf = new strstreambuf;
  3561.   }
  3562.   
  3563. ! ostrstream::ostrstream(char *cp, int n, int mode) : ostream(NULL)
  3564.   {
  3565. !     char *pstart;
  3566. !     if (mode == ios::app || mode == ios::ate)
  3567. !     pstart = cp + strlen(cp);
  3568. !     else
  3569. !     pstart = cp;
  3570. !     _strbuf = new strstreambuf(cp, n, pstart);
  3571. ! }
  3572. ! strstream::strstream() : iostream(NULL)
  3573. ! {
  3574. !     _strbuf = new strstreambuf;
  3575.   }
  3576.   
  3577. ! strstream::strstream(char *cp, int n, int mode) : iostream(NULL)
  3578.   {
  3579.       char *pstart;
  3580.       if (mode == ios::app || mode == ios::ate)
  3581. --- 21,47 ----
  3582.   #include <ioprivat.h>
  3583.   #include <strstrea.h>
  3584.   
  3585. ! static void* default_alloc(_G_size_t size)
  3586.   {
  3587. !     return (void*)new char[size];
  3588.   }
  3589.   
  3590. ! static void default_free(void* ptr)
  3591.   {
  3592. !     delete [] (char*)ptr;
  3593.   }
  3594.   
  3595. ! istrstream::istrstream(const char *cp, _G_size_t n)
  3596.   {
  3597. !     init(new strstreambuf(cp, n));
  3598.   }
  3599.   
  3600. ! ostrstream::ostrstream()
  3601.   {
  3602. !     init(new strstreambuf());
  3603.   }
  3604.   
  3605. ! strstreambase::strstreambase(char *cp, _G_size_t n, int mode)
  3606.   {
  3607.       char *pstart;
  3608.       if (mode == ios::app || mode == ios::ate)
  3609. ***************
  3610. *** 59,72 ****
  3611.       pstart = cp + strlen(cp);
  3612.       else
  3613.       pstart = cp;
  3614. !     _strbuf = new strstreambuf(cp, n, pstart);
  3615.   }
  3616.   
  3617.   char *strstreambuf::str()
  3618.   {
  3619.       freeze(1);
  3620. !     return _buffer;
  3621.   }
  3622.   
  3623.   _G_size_t strstreambuf::pcount()
  3624. --- 48,60 ----
  3625.       pstart = cp + strlen(cp);
  3626.       else
  3627.       pstart = cp;
  3628. !     init(new strstreambuf(cp, n, pstart));
  3629.   }
  3630.   
  3631.   char *strstreambuf::str()
  3632.   {
  3633.       freeze(1);
  3634. !     return base();
  3635.   }
  3636.   
  3637.   _G_size_t strstreambuf::pcount()
  3638. ***************
  3639. *** 76,112 ****
  3640.       return put_len;
  3641.   }
  3642.   
  3643. ! int strstreambuf::overflow(int c = EOF)
  3644.   {
  3645.     const int flush_only = c == EOF;
  3646.     size_t pos = pptr() - pbase();
  3647.     size_t get_pos = gptr() - pbase();
  3648.     if (pos > _len) _len = pos;
  3649. !   if (pos >= _size + flush_only) {
  3650.         char *new_buf;
  3651. !       size_t new_size = 2 * _size;
  3652. !       if (_frozen) /* not allowed to enlarge */
  3653.         return EOF;
  3654. !       else {
  3655. !       new_buf = ALLOC_BUF(new_size);
  3656. !       memcpy(new_buf, _buffer, _size);
  3657. !       }
  3658.         if (new_buf == NULL) {
  3659.   //      __ferror(fp) = 1;
  3660.         return EOF;
  3661.         }
  3662. -       _size = new_size;
  3663.   #if 0
  3664.         if (lenp == &_len) /* use '\0'-filling */
  3665. !       memset(new_buf + pos, 0, _size - pos);
  3666.   #endif
  3667. !       _buffer = new_buf;
  3668. !       setb(new_buf, new_buf + _size, 1);
  3669.       }
  3670.   
  3671. !   setp(_buffer, _buffer + _size);
  3672.     pbump(pos);
  3673. !   setg(_buffer, _buffer + get_pos, _buffer + _len);
  3674.     if (!flush_only) {
  3675.         *pptr() = (unsigned char) c;
  3676.         pbump(1);
  3677. --- 64,102 ----
  3678.       return put_len;
  3679.   }
  3680.   
  3681. ! int strstreambuf::overflow(int c /* = EOF */)
  3682.   {
  3683.     const int flush_only = c == EOF;
  3684. +   if (_flags & _S_NO_WRITES)
  3685. +       return flush_only ? 0 : EOF;
  3686.     size_t pos = pptr() - pbase();
  3687.     size_t get_pos = gptr() - pbase();
  3688.     if (pos > _len) _len = pos;
  3689. !   if (pos >= blen() + flush_only) {
  3690.         char *new_buf;
  3691. !       size_t new_size = 2 * blen();
  3692. !       if (frozen()) /* not allowed to enlarge */
  3693.         return EOF;
  3694. !       new_buf = (char*)(*_allocate_buffer)(new_size);
  3695. !       memcpy(new_buf, base(), blen());
  3696.         if (new_buf == NULL) {
  3697.   //      __ferror(fp) = 1;
  3698.         return EOF;
  3699.         }
  3700.   #if 0
  3701.         if (lenp == &_len) /* use '\0'-filling */
  3702. !       memset(new_buf + pos, 0, blen() - pos);
  3703.   #endif
  3704. !       if (_base) {
  3705. !       (*_free_buffer)(_base);
  3706. !       _base = NULL; // So setb() won't try to delete _base.
  3707. !       }
  3708. !       setb(new_buf, new_buf + new_size, 1);
  3709.       }
  3710.   
  3711. !   setp(base(), ebuf());
  3712.     pbump(pos);
  3713. !   setg(base(), base() + get_pos, base() + _len);
  3714.     if (!flush_only) {
  3715.         *pptr() = (unsigned char) c;
  3716.         pbump(1);
  3717. ***************
  3718. *** 118,124 ****
  3719.   {
  3720.       size_t ppos = pptr() - pbase();
  3721.       if (ppos > _len) _len = ppos;
  3722. !     setg(_buffer, gptr(), _buffer + _len);
  3723.       if (gptr() < egptr())
  3724.       return *gptr();
  3725.       else
  3726. --- 108,114 ----
  3727.   {
  3728.       size_t ppos = pptr() - pbase();
  3729.       if (ppos > _len) _len = ppos;
  3730. !     setg(base(), gptr(), base() + _len);
  3731.       if (gptr() < egptr())
  3732.       return *gptr();
  3733.       else
  3734. ***************
  3735. *** 125,198 ****
  3736.       return EOF;
  3737.   }
  3738.   
  3739. - strstreambuf::strstreambuf()
  3740. - {
  3741. -     _frozen = 0;
  3742. -     _len = 0;
  3743. -     _size = 128;
  3744. -     _buffer = ALLOC_BUF(_size);
  3745. -     setb(_buffer, _buffer+_size);
  3746. -     setp(_buffer, _buffer+_size);
  3747. -     setg(_buffer, _buffer, _buffer);
  3748. - }
  3749.   
  3750. ! strstreambuf::strstreambuf(int initial)
  3751.   {
  3752. -     _frozen = 0;
  3753.       _len = 0;
  3754. !     if (initial < 16)
  3755. !     initial = 16;
  3756. !     _size = initial;
  3757. !     _buffer = ALLOC_BUF(_size);
  3758. !     setb(_buffer, _buffer+_size);
  3759. !     setp(_buffer, _buffer+_size);
  3760. !     setg(_buffer, _buffer, _buffer);
  3761.   }
  3762.   
  3763. ! strstreambuf::strstreambuf(char *ptr, size_t size, char *pstart)
  3764.   {
  3765. -     _frozen = 1;
  3766.       if (size == 0)
  3767. !     _size = strlen(ptr);
  3768. !     else if (size < 0) {
  3769.       // If size is negative 'the characters are assumed to
  3770. !     // continue indefinitely.'
  3771. !     // The following semi-portable kludge tries to do that.
  3772. !     // It assumes that sizeof(long) == sizeof(pointer).
  3773. !     // Hence, (unsigned long)(-1) should be the largest
  3774. !     // possible address.
  3775.       unsigned long highest = (unsigned long)(-1);
  3776.       // Pointers are signed on some brain-damaged systems, in
  3777.       // which case we divide by two to get the maximum signed address.
  3778.       if  ((char*)highest < ptr)
  3779.           highest >>= 1;
  3780. !     _size = (char*)highest - ptr;
  3781.       }
  3782. !     else
  3783. !     _size = size;
  3784. !     _buffer = ptr;
  3785. !     setb(_buffer, _buffer+_size);
  3786.       if (pstart) {
  3787. !     setp(_buffer, _buffer+_size);
  3788. !     pbump(pstart-_buffer);
  3789. !     setg(_buffer, _buffer, pstart);
  3790.       }
  3791.       else {
  3792. !     setp(_buffer, _buffer); 
  3793. !     setg(_buffer, _buffer, _buffer+_size);
  3794.       }
  3795. !     _len = egptr() - _buffer;
  3796.   }
  3797.   
  3798.   strstreambuf::~strstreambuf()
  3799.   {
  3800. !     if (_frozen == 0)
  3801. !         FREE_BUF(_buffer);
  3802.   }
  3803.   
  3804. ! virtual streampos strstreambuf::seekoff(streamoff off, _seek_dir dir,
  3805.                       int mode /*=ios::in|ios::out*/)
  3806.   {
  3807.       size_t cur_size = pcount();
  3808.       streampos new_pos = EOF;
  3809.   
  3810. --- 115,189 ----
  3811.       return EOF;
  3812.   }
  3813.   
  3814.   
  3815. ! void strstreambuf::init_dynamic(_alloc_type alloc, _free_type free,
  3816. !                 _G_size_t initial_size)
  3817. !                 
  3818.   {
  3819.       _len = 0;
  3820. !     if (initial_size < 16)
  3821. !     initial_size = 16;
  3822. !     _allocate_buffer = alloc ? alloc : default_alloc;
  3823. !     _free_buffer = free ? free : default_free;
  3824. !     char * buf = (char*)(*_allocate_buffer)(initial_size);
  3825. !     setb(buf, buf + initial_size, 1);
  3826. !     setp(buf, buf + initial_size);
  3827. !     setg(buf, buf, buf);
  3828.   }
  3829.   
  3830. ! void strstreambuf::init_static(char *ptr, long size, char *pstart)
  3831.   {
  3832.       if (size == 0)
  3833. !     size = strlen(ptr);
  3834. !     else if ((long)size < 0) {
  3835.       // If size is negative 'the characters are assumed to
  3836. !     // continue indefinitely.'  This is kind of messy ...
  3837. ! #if 1
  3838. !     size = 512;
  3839. !     // Try increasing powers of 2, as long as we don't wrap around.
  3840. !     // This can lose in pathological cases (ptr near the end
  3841. !     // of the address space).  A better solution might be to
  3842. !     // adjust the size on underflow/overflow.  FIXME.
  3843. !     for (long s; s = 2*size, s > 0 && ptr + s > ptr && s < 0x4000000L; )
  3844. !         size = s;
  3845. !     size = s;
  3846. ! #else
  3847. !     // The following semi-portable kludge assumes that
  3848. !     // sizeof(unsigned long) == sizeof(char*). Hence,
  3849. !     // (unsigned long)(-1) should be the largest possible address.
  3850.       unsigned long highest = (unsigned long)(-1);
  3851.       // Pointers are signed on some brain-damaged systems, in
  3852.       // which case we divide by two to get the maximum signed address.
  3853.       if  ((char*)highest < ptr)
  3854.           highest >>= 1;
  3855. !     size = (char*)highest - ptr;
  3856. ! #endif
  3857.       }
  3858. !     setb(ptr, ptr+size);
  3859.       if (pstart) {
  3860. !     setp(ptr, ebuf());
  3861. !     pbump(pstart-ptr);
  3862. !     setg(ptr, ptr, pstart);
  3863.       }
  3864.       else {
  3865. !     setp(ptr, ptr); 
  3866. !     setg(ptr, ptr, ebuf());
  3867.       }
  3868. !     _len = egptr() - ptr;
  3869.   }
  3870.   
  3871.   strstreambuf::~strstreambuf()
  3872.   {
  3873. !     if (_base && !(_flags & _S_USER_BUF))
  3874. !         (_free_buffer)(_base);
  3875. !     _base = NULL;
  3876.   }
  3877.   
  3878. ! streampos strstreambuf::seekoff(streamoff off, _seek_dir dir,
  3879.                       int mode /*=ios::in|ios::out*/)
  3880.   {
  3881. +     _allocate_buffer = default_alloc;
  3882. +     _free_buffer = default_free;
  3883.       size_t cur_size = pcount();
  3884.       streampos new_pos = EOF;
  3885.   
  3886. ***************
  3887. *** 210,216 ****
  3888.       }
  3889.       if (off < 0 || (size_t)off > cur_size)
  3890.           return EOF;
  3891. !     setg(_buffer, _buffer + off, _buffer + cur_size);
  3892.       new_pos = off;
  3893.       }
  3894.   
  3895. --- 201,207 ----
  3896.       }
  3897.       if (off < 0 || (size_t)off > cur_size)
  3898.           return EOF;
  3899. !     setg(base(), base() + off, base() + cur_size);
  3900.       new_pos = off;
  3901.       }
  3902.   
  3903. ***************
  3904. *** 228,235 ****
  3905.       }
  3906.       if (off < 0 || (size_t)off > cur_size)
  3907.           return EOF;
  3908. !     pbump(_buffer + off - pptr());
  3909.       new_pos = off;
  3910.       }
  3911.       return new_pos;
  3912.   }
  3913. --- 219,233 ----
  3914.       }
  3915.       if (off < 0 || (size_t)off > cur_size)
  3916.           return EOF;
  3917. !     pbump(base() + off - pptr());
  3918.       new_pos = off;
  3919.       }
  3920.       return new_pos;
  3921. + }
  3922. + int strstreambuf::pbackfail(int c)
  3923. + {
  3924. +     if ((_flags & _S_NO_WRITES) && c != EOF)
  3925. +     return EOF;
  3926. +     return backupbuf::pbackfail(c);
  3927.   }
  3928. *** 1.1    1992/03/22 07:42:32
  3929. --- xsfile.cc    1993/02/22 17:06:46
  3930. ***************
  3931. *** 20,38 ****
  3932.   #endif
  3933.   #include <xsfile.h>
  3934.   
  3935. ! SFile::SFile(const char *filename, size_t size, int mode, int prot)
  3936.   : fstream(filename, mode, prot)
  3937.   { 
  3938.     sz = size; 
  3939.   }
  3940.   
  3941. ! SFile::SFile(int fd, size_t size)
  3942.   : fstream(fd)
  3943.   { 
  3944.     sz = size; 
  3945.   }
  3946.   
  3947. ! void SFile::open(const char *name, size_t size, int mode, int prot)
  3948.   {
  3949.       fstream::open(name, mode, prot);
  3950.       sz = size;
  3951. --- 20,38 ----
  3952.   #endif
  3953.   #include <xsfile.h>
  3954.   
  3955. ! SFile::SFile(const char *filename, _G_size_t size, int mode, int prot)
  3956.   : fstream(filename, mode, prot)
  3957.   { 
  3958.     sz = size; 
  3959.   }
  3960.   
  3961. ! SFile::SFile(int fd, _G_size_t size)
  3962.   : fstream(fd)
  3963.   { 
  3964.     sz = size; 
  3965.   }
  3966.   
  3967. ! void SFile::open(const char *name, _G_size_t size, int mode, int prot)
  3968.   {
  3969.       fstream::open(name, mode, prot);
  3970.       sz = size;
  3971.